@shipload/sdk 1.0.0-next.37 → 1.0.0-next.39

package/src/nft/buildImmutableData.ts

@@ -2,6 +2,7 @@ import {Serializer} from '@wharfkit/antelope'
 import {getItem} from '../data/catalog'
 import {
     getModuleCapabilityType,
+    MODULE_BATTERY,
     MODULE_CRAFTER,
     MODULE_ENGINE,
     MODULE_GATHERER,
@@ -26,6 +27,8 @@ import {
     computeGathererYield,
     computeGeneratorCap,
     computeGeneratorRech,
+    computeCargoBayCapacity,
+    computeBatteryBankCapacity,
     computeHaulerCapacity,
     computeHaulerDrain,
     computeHaulerEfficiency,
@@ -224,11 +227,11 @@ export function buildModuleImmutable(
         }
         case MODULE_CRAFTER: {
             const rea = decodeStat(stats, 0)
-            const fin = decodeStat(stats, 1)
+            const con = decodeStat(stats, 1)
             base.push({first: 'reactivity', second: ['uint16', rea]})
-            base.push({first: 'fineness', second: ['uint16', fin]})
+            base.push({first: 'conductivity', second: ['uint16', con]})
             base.push({first: 'speed', second: ['uint16', computeCrafterSpeed(rea)]})
-            base.push({first: 'drain', second: ['uint16', computeCrafterDrain(fin)]})
+            base.push({first: 'drain', second: ['uint16', computeCrafterDrain(con)]})
             break
         }
         case MODULE_STORAGE: {
@@ -236,14 +239,28 @@ export function buildModuleImmutable(
             const den = decodeStat(stats, 1)
             const hrd = decodeStat(stats, 2)
             const com = decodeStat(stats, 3)
-            const sum = str + den + hrd + com
             base.push({first: 'strength', second: ['uint16', str]})
             base.push({first: 'density', second: ['uint16', den]})
             base.push({first: 'hardness', second: ['uint16', hrd]})
             base.push({first: 'cohesion', second: ['uint16', com]})
             base.push({
-                first: 'capacity_bonus_pct',
-                second: ['uint16', 10 + Math.floor((sum * 10) / 2997)],
+                first: 'capacity',
+                second: ['uint32', computeCargoBayCapacity(str, den, hrd, com)],
+            })
+            break
+        }
+        case MODULE_BATTERY: {
+            const vol = decodeStat(stats, 0)
+            const thm = decodeStat(stats, 1)
+            const pla = decodeStat(stats, 2)
+            const ins = decodeStat(stats, 3)
+            base.push({first: 'volatility', second: ['uint16', vol]})
+            base.push({first: 'thermal', second: ['uint16', thm]})
+            base.push({first: 'plasticity', second: ['uint16', pla]})
+            base.push({first: 'insulation', second: ['uint16', ins]})
+            base.push({
+                first: 'capacity',
+                second: ['uint32', computeBatteryBankCapacity(vol, thm, pla, ins)],
             })
             break
         }

package/src/nft/description.ts

@@ -4,6 +4,7 @@ import {
     MODULE_ENGINE,
     MODULE_GATHERER,
     MODULE_GENERATOR,
+    MODULE_BATTERY,
     MODULE_HAULER,
     MODULE_LOADER,
     MODULE_STORAGE,
@@ -19,6 +20,7 @@ import {
     ITEM_GATHERER_T1,
     ITEM_GENERATOR_T1,
     ITEM_HAULER_T1,
+    ITEM_BATTERY_T1,
     ITEM_LOADER_T1,
     ITEM_SHIP_T1_PACKED,
     ITEM_STORAGE_T1,
@@ -60,6 +62,16 @@ export function computeBaseCapacityWarehouse(stats: bigint): number {
 
 export const computeEngineThrust = (vol: number): number => 400 + idiv(vol * 3, 4)
 export const computeEngineDrain = (thm: number): number => 2 * Math.max(30, 50 - idiv(thm, 70))
+export const ENGINE_DRAIN_BASE = 118
+export const ENGINE_DRAIN_REF_THRUST = 775
+export const ENGINE_DRAIN_REF_THM = 500
+
+export const computeTravelDrain = (totalThrust: number, avgThm: number): number => {
+    if (totalThrust <= 0) return 0
+    const num = ENGINE_DRAIN_BASE * ENGINE_DRAIN_REF_THRUST * computeEngineDrain(avgThm)
+    const den = totalThrust * computeEngineDrain(ENGINE_DRAIN_REF_THM)
+    return idiv(num, den)
+}
 export const computeGeneratorCap = (com: number): number => 950 + idiv(com, 2)
 export const computeGeneratorRech = (fin: number): number => 2 * (1 + idiv(fin * 3, 1000))
 export const computeGathererYield = (str: number): number => 200 + str
@@ -75,6 +87,18 @@ export const computeHaulerCapacity = (fin: number): number => Math.max(1, 1 + id
 export const computeHaulerEfficiency = (con: number): number => 2000 + con * 6
 export const computeHaulerDrain = (com: number): number => Math.max(3, 15 - idiv(com, 80))
 export const computeWarpRange = (stat: number): number => 100 + stat * 3
+export const computeCargoBayCapacity = (
+    strength: number,
+    density: number,
+    hardness: number,
+    cohesion: number
+): number => 10_000_000 + idiv((strength + density + hardness + cohesion) * 50_000_000, 3996)
+export const computeBatteryBankCapacity = (
+    volatility: number,
+    thermal: number,
+    plasticity: number,
+    insulation: number
+): number => 2_500 + idiv((volatility + thermal + plasticity + insulation) * 7_500, 3996)
 
 export function entityDisplayName(itemId: number): string {
     switch (itemId) {
@@ -108,11 +132,13 @@ export function moduleDisplayName(itemId: number): string {
         case ITEM_CRAFTER_T1:
             return 'Crafter'
         case ITEM_STORAGE_T1:
-            return 'Storage'
+            return 'Cargo Bay'
         case ITEM_HAULER_T1:
             return 'Hauler'
         case ITEM_WARP_T1:
             return 'Warp'
+        case ITEM_BATTERY_T1:
+            return 'Battery Bank'
         default:
             return 'Module'
     }
@@ -160,17 +186,16 @@ export function formatModuleLine(slot: number, itemId: number, stats: bigint): s
         }
         case MODULE_CRAFTER: {
             const rea = decodeStat(stats, 0)
-            const com = decodeStat(stats, 1)
-            out += `  Speed ${computeCrafterSpeed(rea)}  Drain ${computeCrafterDrain(com)}`
+            const con = decodeStat(stats, 1)
+            out += `  Speed ${computeCrafterSpeed(rea)}  Drain ${computeCrafterDrain(con)}`
             break
         }
         case MODULE_STORAGE: {
             const str = decodeStat(stats, 0)
-            const fin = decodeStat(stats, 2)
-            const sat = decodeStat(stats, 3)
-            const sum = str + fin + sat
-            const pct = 10 + idiv(sum * 10, 2997)
-            out += `  +${pct}% capacity`
+            const den = decodeStat(stats, 1)
+            const hrd = decodeStat(stats, 2)
+            const com = decodeStat(stats, 3)
+            out += `  Cargo Capacity ${computeCargoBayCapacity(str, den, hrd, com)}`
             break
         }
         case MODULE_HAULER: {
@@ -185,6 +210,14 @@ export function formatModuleLine(slot: number, itemId: number, stats: bigint): s
             out += `  Range ${computeWarpRange(stat)}`
             break
         }
+        case MODULE_BATTERY: {
+            const vol = decodeStat(stats, 0)
+            const thm = decodeStat(stats, 1)
+            const pla = decodeStat(stats, 2)
+            const ins = decodeStat(stats, 3)
+            out += `  Energy Capacity ${computeBatteryBankCapacity(vol, thm, pla, ins)}`
+            break
+        }
     }
     return out
 }

package/src/resolution/describe-module.ts

@@ -81,9 +81,15 @@ const TEMPLATES: Record<string, TemplateSpec> = {
     },
     storage: {
         id: 'module.storage.description',
-        template: 'boosts cargo capacity by {bonus}%',
-        params: [['bonus', 'Capacity Bonus']],
-        highlightKeys: ['bonus'],
+        template: 'adds {capacity} cargo capacity',
+        params: [['capacity', 'Cargo Capacity']],
+        highlightKeys: ['capacity'],
+    },
+    energy: {
+        id: 'module.energy-capacity.description',
+        template: 'adds {capacity} energy capacity',
+        params: [['capacity', 'Energy Capacity']],
+        highlightKeys: ['capacity'],
     },
     hauler: {
         id: 'module.hauler.description',
@@ -124,8 +130,10 @@ export function describeModuleForItem(resolved: ResolvedItem): ModuleDescription
 }
 
 export function describeModuleForSlot(slot: ResolvedModuleSlot): ModuleDescription | null {
-    if (!slot.installed || !slot.name || !slot.attributes) return null
-    return describeModule({capability: slot.name, attributes: slot.attributes})
+    if (!slot.installed || !slot.attributes) return null
+    const capability = slot.capability ?? slot.name
+    if (!capability) return null
+    return describeModule({capability, attributes: slot.attributes})
 }
 
 export function renderDescription(

package/src/resolution/resolve-item.test.ts

@@ -0,0 +1,37 @@
+import {expect, test} from 'bun:test'
+import {UInt16, UInt64} from '@wharfkit/antelope'
+import {resolveItem} from './resolve-item'
+import {encodeStats} from '../derivation/crafting'
+import {computeContainerCapabilities} from '../derivation/capabilities'
+import {
+    ITEM_EXTRACTOR_T1_PACKED,
+    ITEM_FACTORY_T1_PACKED,
+    ITEM_MASS_DRIVER_T1_PACKED,
+    ITEM_MASS_CATCHER_T1_PACKED,
+} from '../data/item-ids'
+
+function hullStats(strength: number, density: number, hardness: number): UInt64 {
+    return UInt64.from(encodeStats([strength, density, hardness]).toString())
+}
+
+const CONTAINER_ENTITIES = [
+    ['factory', ITEM_FACTORY_T1_PACKED],
+    ['extractor', ITEM_EXTRACTOR_T1_PACKED],
+    ['mass driver', ITEM_MASS_DRIVER_T1_PACKED],
+    ['mass catcher', ITEM_MASS_CATCHER_T1_PACKED],
+] as const
+
+for (const [label, itemId] of CONTAINER_ENTITIES) {
+    test(`resolveItem resolves ${label} hull capacity via container formula`, () => {
+        const stats = hullStats(300, 100, 400)
+        const resolved = resolveItem(UInt16.from(itemId), stats)
+        const hull = resolved.attributes?.find((g) => g.capability === 'Hull')
+        const capacity = hull?.attributes.find((a) => a.label === 'Capacity')?.value
+        const expected = computeContainerCapabilities({
+            strength: 300,
+            hardness: 400,
+            density: 100,
+        }).capacity
+        expect(capacity).toBe(expected)
+    })
+}

package/src/resolution/resolve-item.ts

@@ -9,6 +9,7 @@ import {
     isModuleItem,
     MODULE_CRAFTER,
     MODULE_ENGINE,
+    MODULE_BATTERY,
     MODULE_GATHERER,
     MODULE_GENERATOR,
     MODULE_HAULER,
@@ -19,6 +20,7 @@ import {decodeCraftedItemStats, decodeStat} from '../derivation/crafting'
 import {getStatDefinitions} from '../derivation/stats'
 import {
     computeCrafterCapabilities,
+    computeBatteryCapabilities,
     computeEngineCapabilities,
     computeGathererCapabilities,
     computeGeneratorCapabilities,
@@ -28,13 +30,18 @@ import {
     computeWarehouseHullCapabilities,
     computeContainerCapabilities,
     computeContainerT2Capabilities,
+    computeStorageCapabilities,
 } from '../derivation/capabilities'
+import {applySlotMultiplierUint32} from '../entities/slot-multiplier'
 import {categoryColors, componentIcon, itemAbbreviations, moduleIcon} from '../data/colors'
 import type {ServerContract} from '../contracts'
 import {
     ITEM_CONTAINER_T1_PACKED,
     ITEM_CONTAINER_T2_PACKED,
     ITEM_EXTRACTOR_T1_PACKED,
+    ITEM_FACTORY_T1_PACKED,
+    ITEM_MASS_CATCHER_T1_PACKED,
+    ITEM_MASS_DRIVER_T1_PACKED,
     ITEM_SHIP_T1_PACKED,
     ITEM_WAREHOUSE_T1_PACKED,
 } from '../data/item-ids'
@@ -58,6 +65,7 @@ export type ResolvedItemType = 'resource' | 'component' | 'module' | 'entity'
 
 export interface ResolvedModuleSlot {
     name?: string
+    capability?: string
     installed: boolean
     attributes?: {label: string; value: number}[]
 }
@@ -152,7 +160,8 @@ function resolveComponent(id: number, stats?: UInt64Type): ResolvedItem {
 function computeCapabilityGroup(
     moduleType: number,
     stats: Record<string, number>,
-    tier: number
+    tier: number,
+    outputPct = 100
 ): ResolvedAttributeGroup | undefined {
     switch (moduleType) {
         case MODULE_ENGINE: {
@@ -219,13 +228,28 @@ function computeCapabilityGroup(
             }
         }
         case MODULE_STORAGE: {
-            const str = stats.strength
-            const den = stats.density
-            const hrd = stats.hardness
-            const com = stats.cohesion
-            const statSum = str + den + hrd + com
-            const pct = 10 + Math.floor((statSum * 10) / 2997)
-            return {capability: 'Storage', attributes: [{label: 'Capacity Bonus', value: pct}]}
+            const caps = computeStorageCapabilities(stats)
+            return {
+                capability: 'Storage',
+                attributes: [
+                    {
+                        label: 'Cargo Capacity',
+                        value: applySlotMultiplierUint32(caps.capacity, outputPct),
+                    },
+                ],
+            }
+        }
+        case MODULE_BATTERY: {
+            const caps = computeBatteryCapabilities(stats)
+            return {
+                capability: 'Energy',
+                attributes: [
+                    {
+                        label: 'Energy Capacity',
+                        value: applySlotMultiplierUint32(caps.capacity, outputPct),
+                    },
+                ],
+            }
         }
         default:
             return undefined
@@ -266,7 +290,9 @@ function hullCapsForEntity(
         case ITEM_WAREHOUSE_T1_PACKED:
             return computeWarehouseHullCapabilities(decoded)
         case ITEM_EXTRACTOR_T1_PACKED:
-            return computeShipHullCapabilities(decoded)
+        case ITEM_FACTORY_T1_PACKED:
+        case ITEM_MASS_DRIVER_T1_PACKED:
+        case ITEM_MASS_CATCHER_T1_PACKED:
         case ITEM_CONTAINER_T1_PACKED:
             return computeContainerCapabilities(decoded)
         case ITEM_CONTAINER_T2_PACKED:
@@ -321,9 +347,10 @@ function resolveEntity(
                 } catch {
                     modName = itemMetadata[modItemId]?.name ?? 'Module'
                 }
-                const group = computeCapabilityGroup(modType, decodedStats, modTier)
+                const group = computeCapabilityGroup(modType, decodedStats, modTier, slot.outputPct)
                 return {
                     name: modName,
+                    capability: group?.capability,
                     installed: true,
                     attributes: group?.attributes,
                 }

package/src/scheduling/projection.ts

@@ -41,6 +41,7 @@ export interface ProjectedEntity {
     loaderLanes: ServerContract.Types.loader_lane[]
     generator?: ServerContract.Types.energy_stats
     hauler?: ServerContract.Types.hauler_stats
+    launcher?: ServerContract.Types.launcher_stats
     readonly cargoMass: UInt64
     readonly totalMass: UInt64
     readonly gathererLanes: ServerContract.Types.gatherer_lane[]
@@ -49,6 +50,7 @@ export interface ProjectedEntity {
     hasMovement(): boolean
     hasStorage(): boolean
     hasLoaders(): boolean
+    hasLauncher(): boolean
 
     capabilities(): EntityCapabilities
     state(): EntityState
@@ -64,6 +66,7 @@ export interface Projectable extends ScheduleData {
     gatherer_lanes?: ServerContract.Types.gatherer_lane[]
     crafter_lanes?: ServerContract.Types.crafter_lane[]
     hauler?: ServerContract.Types.hauler_stats
+    launcher?: ServerContract.Types.launcher_stats
     capacity?: UInt32
     cargo: ServerContract.Types.cargo_item[]
     cargomass: UInt32
@@ -91,6 +94,7 @@ interface ProjectedCaps {
     gathererLanes: ServerContract.Types.gatherer_lane[]
     crafterLanes: ServerContract.Types.crafter_lane[]
     hauler?: ServerContract.Types.hauler_stats
+    launcher?: ServerContract.Types.launcher_stats
 }
 
 function recomputeCaps(entity: Projectable): ProjectedCaps | undefined {
@@ -164,6 +168,13 @@ function recomputeCaps(entity: Projectable): ProjectedCaps | undefined {
         gathererLanes: (caps.gathererLanes ?? []).map(toGathererLane),
         crafterLanes: (caps.crafterLanes ?? []).map(toCrafterLane),
         hauler: caps.hauler ? ServerContract.Types.hauler_stats.from(caps.hauler) : undefined,
+        launcher: caps.launcher
+            ? ServerContract.Types.launcher_stats.from({
+                  charge_rate: caps.launcher.chargeRate,
+                  velocity: caps.launcher.velocity,
+                  drain: caps.launcher.drain,
+              })
+            : undefined,
     }
 }
 
@@ -180,6 +191,7 @@ export function createProjectedEntity(entity: Projectable): ProjectedEntity {
         entity.engines === undefined ||
         entity.generator === undefined ||
         entity.hauler === undefined ||
+        entity.launcher === undefined ||
         entity.capacity === undefined
     const caps = needsRecompute ? recomputeCaps(entity) : undefined
 
@@ -190,6 +202,7 @@ export function createProjectedEntity(entity: Projectable): ProjectedEntity {
     const engines = entity.engines ?? caps?.engines
     const generator = entity.generator ?? caps?.generator
     const hauler = entity.hauler ?? caps?.hauler
+    const launcher = entity.launcher ?? caps?.launcher
     const capacity = entity.capacity ?? caps?.capacity
 
     const cargo: CargoStack[] = entity.cargo.map(cargoItemToStack)
@@ -203,6 +216,7 @@ export function createProjectedEntity(entity: Projectable): ProjectedEntity {
         engines,
         generator,
         hauler,
+        launcher,
         loaderLanes,
         gathererLanes,
         crafterLanes,
@@ -229,12 +243,17 @@ export function createProjectedEntity(entity: Projectable): ProjectedEntity {
             return this.loaderLanes.length > 0
         },
 
+        hasLauncher() {
+            return this.launcher !== undefined
+        },
+
         capabilities(): EntityCapabilities {
             return {
                 hullmass: this.shipMass,
                 capacity: this.capacity ? UInt32.from(this.capacity) : undefined,
                 engines: this.engines,
                 generator: this.generator,
+                launcher: this.launcher,
             }
         },
 

package/src/travel/route-planner.ts

@@ -32,6 +32,7 @@ export interface RouteFailure {
     reason: RouteFailureReason
     furthest?: Coord
     legsNeeded?: number
+    partialWaypoints?: Coord[]
 }
 
 export type RouteResult = RoutePlan | RouteFailure
@@ -50,11 +51,13 @@ const key = (c: Coord): string => `${c.x},${c.y}`
 const sameCoord = (a: Coord, b: Coord): boolean => a.x === b.x && a.y === b.y
 const dist = (a: Coord, b: Coord): number => Math.hypot(a.x - b.x, a.y - b.y)
 
+export const MAX_LEGS = 12
+
 export function planRoute(params: PlanRouteParams): RouteResult {
     const {origin, dest, perLegReach, graph} = params
     const corridorSlack = params.corridorSlack ?? perLegReach
     const nodeBudget = params.nodeBudget ?? 5000
-    const maxLegs = params.maxLegs ?? 12
+    const maxLegs = params.maxLegs ?? MAX_LEGS
 
     if (!graph.hasSystem(dest)) {
         return {ok: false, reason: 'empty-destination'}
@@ -122,9 +125,32 @@ export function planRoute(params: PlanRouteParams): RouteResult {
     }
 
     if (cappedByMaxLegs) {
-        return {ok: false, reason: 'max-legs', furthest}
+        return {
+            ok: false,
+            reason: 'max-legs',
+            furthest,
+            partialWaypoints: reconstructWaypoints(cameFrom, origin, furthest),
+        }
+    }
+    return {
+        ok: false,
+        reason: 'no-path',
+        furthest,
+        partialWaypoints: reconstructWaypoints(cameFrom, origin, furthest),
+    }
+}
+
+function reconstructWaypoints(cameFrom: Map<string, Coord>, origin: Coord, target: Coord): Coord[] {
+    if (sameCoord(target, origin)) return []
+    const path: Coord[] = [target]
+    let cur = target
+    while (!sameCoord(cur, origin)) {
+        const prev = cameFrom.get(key(cur))
+        if (!prev) break
+        path.unshift(prev)
+        cur = prev
     }
-    return {ok: false, reason: 'no-path', furthest}
+    return path.slice(1)
 }
 
 function reconstruct(cameFrom: Map<string, Coord>, origin: Coord, dest: Coord): RoutePlan {

package/src/types/capabilities.ts

@@ -59,6 +59,7 @@ export interface EntityCapabilities {
     gatherer?: GathererStats
     crafter?: CrafterStats
     hauler?: ServerContract.Types.hauler_stats
+    launcher?: ServerContract.Types.launcher_stats
 }
 
 export interface EntityState {
@@ -92,3 +93,7 @@ export function capsHasMass(caps: EntityCapabilities): boolean {
 export function capsHasHauler(caps: EntityCapabilities): boolean {
     return caps.hauler !== undefined
 }
+
+export function capsHasLauncher(caps: EntityCapabilities): boolean {
+    return caps.launcher !== undefined
+}

package/src/types.ts

@@ -129,6 +129,7 @@ export type ModuleType =
     | 'storage'
     | 'hauler'
     | 'battery'
+    | 'catcher'
 
 export const RESOURCE_TIER_ADJECTIVES: Record<number, string> = {
     1: 'Crude',