@shipload/sdk 1.0.0-next.51 → 1.0.0-next.52

package/src/travel/route-planner.ts

@@ -1,7 +1,4 @@
-import {distanceBetweenPoints, findNearbyPlanets} from './travel'
-import {hasSystem} from '../utils/system'
 import {nearbyWormholes, wormholeAt} from '../derivation/wormhole'
-import {PRECISION} from '../types'
 import {Checksum256, type Checksum256Type} from '@wharfkit/antelope'
 
 export interface Coord {
@@ -26,6 +23,19 @@ export interface RoutePlan {
     totalDistance: number
 }
 
+export interface RouteLegInput {
+    from: Coord
+    to: Coord
+    distance: number
+    isDestination: boolean
+}
+
+/**
+ * Returns the elapsed-time search cost for a leg, or null when the leg is not contract-feasible.
+ */
+export type RouteLegCost = (leg: RouteLegInput) => number | null
+export type RouteHeuristicCost = (from: Coord, dest: Coord) => number
+
 export type RouteFailureReason = 'empty-destination' | 'no-path' | 'max-legs'
 
 export interface RouteFailure {
@@ -46,6 +56,8 @@ export interface PlanRouteParams {
     corridorSlack?: number
     nodeBudget?: number
     maxLegs?: number
+    legCost?: RouteLegCost
+    heuristicCost?: RouteHeuristicCost
 }
 
 const key = (c: Coord): string => `${c.x},${c.y}`
@@ -65,12 +77,25 @@ export function planRoute(params: PlanRouteParams): RouteResult {
     }
 
     const straightLine = dist(origin, dest)
-    const heuristic = (c: Coord): number => Math.ceil(dist(c, dest) / perLegReach)
+    if (straightLine <= perLegReach) {
+        const directCost = params.legCost?.({
+            from: origin,
+            to: dest,
+            distance: straightLine,
+            isDestination: true,
+        })
+        if (directCost !== null) {
+            return {ok: true, waypoints: [dest], legs: 1, totalDistance: straightLine}
+        }
+    }
+    const heuristic = (c: Coord): number =>
+        params.heuristicCost?.(c, dest) ??
+        (params.legCost ? 0 : Math.ceil(dist(c, dest) / perLegReach))
 
     const gScore = new Map<string, number>([[key(origin), 0]])
     const cameFrom = new Map<string, Coord>()
-    const frontier: {coord: Coord; g: number; f: number; remaining: number}[] = [
-        {coord: origin, g: 0, f: heuristic(origin), remaining: straightLine},
+    const frontier: {coord: Coord; legs: number; cost: number; f: number; remaining: number}[] = [
+        {coord: origin, legs: 0, cost: 0, f: heuristic(origin), remaining: straightLine},
     ]
 
     let furthest = origin
@@ -88,6 +113,7 @@ export function planRoute(params: PlanRouteParams): RouteResult {
             }
         }
         const current = frontier.splice(bestIdx, 1)[0]
+        if (current.cost !== gScore.get(key(current.coord))) continue
 
         if (sameCoord(current.coord, dest)) {
             return reconstruct(cameFrom, origin, dest)
@@ -105,20 +131,31 @@ export function planRoute(params: PlanRouteParams): RouteResult {
                 dist(origin, n.coord) + dist(n.coord, dest) <= straightLine + corridorSlack
             if (!inCorridor) continue
 
-            const tentativeG = current.g + 1
-            if (tentativeG > maxLegs) {
+            const tentativeLegs = current.legs + 1
+            if (tentativeLegs > maxLegs) {
                 cappedByMaxLegs = true
                 continue
             }
+            const evaluatedCost = params.legCost?.({
+                from: current.coord,
+                to: n.coord,
+                distance: n.dist,
+                isDestination: sameCoord(n.coord, dest),
+            })
+            if (evaluatedCost === null) continue
+            const legCost = evaluatedCost ?? 1
+            if (!(legCost >= 0) || !Number.isFinite(legCost)) continue
             const nk = key(n.coord)
-            if (tentativeG < (gScore.get(nk) ?? Infinity)) {
-                gScore.set(nk, tentativeG)
+            const nextCost = current.cost + legCost
+            if (nextCost < (gScore.get(nk) ?? Infinity)) {
+                gScore.set(nk, nextCost)
                 cameFrom.set(nk, current.coord)
                 const remaining = dist(n.coord, dest)
                 frontier.push({
                     coord: n.coord,
-                    g: tentativeG,
-                    f: tentativeG + Math.ceil(remaining / perLegReach),
+                    legs: tentativeLegs,
+                    cost: nextCost,
+                    f: nextCost + heuristic(n.coord),
                     remaining,
                 })
             }
@@ -180,50 +217,24 @@ export interface ScanProvider {
     ): {x: number; y: number; locType: number}[]
 }
 
-let scanProvider: ScanProvider | null = null
-const graphCache = new Map<string, SystemGraph>()
-
-// Inject a fast (e.g. wasm) location-type backend; null restores the pure-JS path. Clears the graph cache.
-export function setScanProvider(provider: ScanProvider | null): void {
-    scanProvider = provider
-    graphCache.clear()
-}
+// Keyed by provider identity, so pass a stable one (the `@shipload/sdk/scan` namespace).
+const graphCache = new WeakMap<ScanProvider, Map<string, SystemGraph>>()
 
-export function sdkSystemGraph(seed: Checksum256Type): SystemGraph {
+export function sdkSystemGraph(seed: Checksum256Type, scan: ScanProvider): SystemGraph {
     const s = Checksum256.from(seed)
     const seedHex = s.toString()
-    const cached = graphCache.get(seedHex)
+    let bySeed = graphCache.get(scan)
+    if (!bySeed) {
+        bySeed = new Map()
+        graphCache.set(scan, bySeed)
+    }
+    const cached = bySeed.get(seedHex)
     if (cached) return cached
-    const graph = scanProvider ? wasmSystemGraph(s, seedHex, scanProvider) : jsSystemGraph(s)
-    graphCache.set(seedHex, graph)
+    const graph = wasmSystemGraph(s, seedHex, scan)
+    bySeed.set(seedHex, graph)
     return graph
 }
 
-// Travelable nodes mirror the contract's is_travelable: systems plus wormhole mouths.
-function jsSystemGraph(s: Checksum256): SystemGraph {
-    return {
-        hasSystem: (c) => hasSystem(s, {x: c.x, y: c.y}) || wormholeAt(s, c.x, c.y) !== null,
-        nearby: (c, reachTiles) => {
-            const seen = new Set<string>([`${c.x},${c.y}`])
-            const out: Neighbor[] = []
-            for (const d of findNearbyPlanets(s, {x: c.x, y: c.y}, reachTiles * PRECISION)) {
-                const coord = {x: Number(d.destination.x), y: Number(d.destination.y)}
-                const k = `${coord.x},${coord.y}`
-                if (seen.has(k)) continue
-                seen.add(k)
-                out.push({coord, dist: Number(d.distance) / PRECISION})
-            }
-            for (const coord of nearbyWormholes(s, c.x, c.y, reachTiles)) {
-                const k = `${coord.x},${coord.y}`
-                if (seen.has(k)) continue
-                seen.add(k)
-                out.push({coord, dist: Math.hypot(coord.x - c.x, coord.y - c.y)})
-            }
-            return out
-        },
-    }
-}
-
 const SCAN_BUCKET = 48
 
 function wasmSystemGraph(s: Checksum256, seedHex: string, scan: ScanProvider): SystemGraph {

package/src/travel/route-simulator.ts

@@ -12,7 +12,7 @@ export interface RouteMoverInput {
     hasMovement: boolean
     engines?: {thrust: number; drain: number}
     generator?: {capacity: number; recharge: number}
-    hauler?: {capacity: number; drain: number; efficiency: number}
+    hauler?: {capacity: number; efficiency: number}
     mass: number
     energy: number
     priorMobilityEnd: number
@@ -80,18 +80,14 @@ export function simulateRoute(
     for (const to of waypoints) {
         const distance = distanceBetweenPoints(from.x, from.y, to.x, to.y)
         const distanceNum = Number(distance)
-        const distanceCells = Math.trunc(distanceNum / PRECISION)
+        const distanceCells = distanceNum / PRECISION
 
         const energyCostByMover: Record<string, number> = {}
 
         for (const m of movers) {
             if (!m.hasMovement || !m.engines) continue
             const key = String(m.ref.entityId)
-            let cost = Number(calc_energyusage(distance, m.engines.drain))
-            if (m.hauler) {
-                cost += Math.trunc(distanceCells) * m.hauler.drain * haulCount
-            }
-            energyCostByMover[key] = cost
+            energyCostByMover[key] = Number(calc_energyusage(distance, m.engines.drain))
         }
 
         let rechargeBefore = false

package/src/travel/travel.ts

@@ -14,7 +14,6 @@ import {
     type Checksum256,
     Int64,
     type Int64Type,
-    UInt16,
     UInt32,
     type UInt32Type,
     UInt64,
@@ -197,7 +196,7 @@ export function calc_ship_rechargetime(ship: ShipLike): UInt32 {
     if (!ship.generator) return UInt32.from(0)
     return calc_rechargetime(
         ship.generator.capacity,
-        ship.energy ?? UInt16.from(0),
+        ship.energy ?? UInt32.from(0),
         ship.generator.recharge
     )
 }
@@ -206,6 +205,16 @@ export function calc_flighttime(distance: UInt64Type, acceleration: number): UIn
     return UInt32.from(2 * Math.sqrt(Number(distance) / acceleration))
 }
 
+export function calc_travel_flighttime(distance: UInt64Type, acceleration: number): UInt32 {
+    const cruiseTransitionDistance = 2 * PRECISION
+    if (Number(distance) <= cruiseTransitionDistance) {
+        return calc_flighttime(distance, acceleration)
+    }
+
+    const cruiseVelocity = Math.sqrt(acceleration * cruiseTransitionDistance)
+    return UInt32.from(Number(distance) / cruiseVelocity + cruiseVelocity / acceleration)
+}
+
 export function calc_transit_duration(ax: number, ay: number, bx: number, by: number): UInt32 {
     const distance = distanceBetweenPoints(ax, ay, bx, by)
     return UInt32.from(Math.floor(distance.toNumber() / (PRECISION * WH.TRANSIT_SPEED)))
@@ -235,7 +244,7 @@ export function calc_loader_acceleration(ship: ShipLike, mass: UInt64): number {
 
 export function calc_ship_flighttime(ship: ShipLike, mass: UInt64, distance: UInt64): UInt32 {
     const acceleration = calc_ship_acceleration(ship, mass)
-    return calc_flighttime(distance, acceleration)
+    return calc_travel_flighttime(distance, acceleration)
 }
 
 export function calc_ship_acceleration(ship: ShipLike, mass: UInt64): number {
@@ -286,11 +295,11 @@ export function calc_group_flighttime(
         effectiveThrust = Math.trunc((totalThrust * 1000) / penaltyMilli)
     }
     const acceleration = calc_acceleration(effectiveThrust, totalMass)
-    return calc_flighttime(distance, acceleration)
+    return calc_travel_flighttime(distance, acceleration)
 }
 
 export function calc_energyusage(distance: UInt64Type, drain: UInt32Type): UInt32 {
-    return UInt64.from(distance).dividing(PRECISION).multiplying(drain)
+    return UInt64.from(distance).multiplying(drain).dividing(PRECISION)
 }
 
 export function calculateTransferTime(

package/src/types/capabilities.ts

@@ -1,4 +1,4 @@
-import type {Name, UInt16, UInt32, UInt8} from '@wharfkit/antelope'
+import type {Name, UInt32, UInt8} from '@wharfkit/antelope'
 import type {ServerContract} from '../contracts'
 
 export interface LoaderStats {
@@ -18,13 +18,18 @@ export interface CrafterStats {
     drain: {toNumber(): number}
 }
 
+export interface BuilderStats {
+    speed: {toNumber(): number}
+    drain: {toNumber(): number}
+}
+
 export interface MovementCapability {
     engines: ServerContract.Types.movement_stats
     generator: ServerContract.Types.energy_stats
 }
 
 export interface EnergyCapability {
-    energy: UInt16
+    energy: UInt32
 }
 
 export interface StorageCapability {
@@ -58,6 +63,7 @@ export interface EntityCapabilities {
     loaders?: LoaderStats
     gatherer?: GathererStats
     crafter?: CrafterStats
+    builder?: BuilderStats
     hauler?: ServerContract.Types.hauler_stats
     launcher?: ServerContract.Types.launcher_stats
 }
@@ -65,7 +71,7 @@ export interface EntityCapabilities {
 export interface EntityState {
     owner: Name
     location: ServerContract.Types.coordinates
-    energy?: UInt16
+    energy?: UInt32
     cargomass: UInt32
     cargo: ServerContract.Types.cargo_item[]
 }

package/src/types.ts

@@ -38,7 +38,7 @@ export interface ClusterSlotType {
 export interface ShipLike {
     coordinates: ServerContract.Types.coordinates
     hullmass?: UInt32
-    energy?: UInt16
+    energy?: UInt32
     engines?: ServerContract.Types.movement_stats
     generator?: ServerContract.Types.energy_stats
     loader_lanes?: ServerContract.Types.loader_lane[]
@@ -60,15 +60,15 @@ export enum TaskType {
     GATHER = 5,
     WARP = 6,
     CRAFT = 7,
-    DEPLOY = 8,
     TRANSIT = 9,
     UNWRAP = 10,
     UNDEPLOY = 11,
+    LAUNCH = 12,
     DEMOLISH = 13,
-    CLAIMPLOT = 14,
     BUILDPLOT = 15,
     CHARGE = 16,
     UPGRADE = 17,
+    SHUTTLE = 18,
 }
 
 export enum HoldKind {
@@ -76,6 +76,7 @@ export enum HoldKind {
     PUSH = 2,
     GATHER = 3,
     BUILD = 4,
+    FLIGHT = 5,
     UPGRADE = 6,
 }
 
@@ -138,6 +139,7 @@ export type ModuleType =
     | 'loader'
     | 'warp'
     | 'crafter'
+    | 'builder'
     | 'launcher'
     | 'storage'
     | 'hauler'

package/src/managers/flatten-gather-plan.test.ts

@@ -1,80 +0,0 @@
-import {expect, test, describe} from 'bun:test'
-import {makeClient} from '@wharfkit/mock-data'
-import {Serializer} from '@wharfkit/antelope'
-import type {GatherPlan} from '../planner'
-import {ActionsManager} from './actions'
-import {ServerContract} from '../contracts'
-
-const client = makeClient('https://jungle4.greymass.com')
-
-function makeActions() {
-    const realServer = new ServerContract.Contract({client})
-    const stubServer = {
-        account: realServer.account,
-        action: realServer.action.bind(realServer),
-    }
-    const context = {server: stubServer} as any
-    return new ActionsManager(context)
-}
-
-function fakePlan(): GatherPlan {
-    return {
-        cycles: [
-            {
-                rechargeBefore: false,
-                rechargeSeconds: 0,
-                gatherSeconds: 10,
-                batchOre: 30,
-                limpets: [
-                    {slot: 0, quantity: 20, durationSeconds: 10},
-                    {slot: 1, quantity: 10, durationSeconds: 8},
-                ],
-            },
-            {
-                rechargeBefore: true,
-                rechargeSeconds: 5,
-                gatherSeconds: 10,
-                batchOre: 30,
-                limpets: [{slot: 0, quantity: 30, durationSeconds: 10}],
-            },
-        ],
-        cycleCount: 2,
-        totalOre: 60,
-        totalSeconds: 25,
-        cap: 'requested',
-        reachingCount: 2,
-        totalLimpets: 2,
-        warnings: [],
-    }
-}
-
-describe('flattenGatherPlan', () => {
-    test('flattens cycles to [recharge?, gather x limpets] in order with slots', () => {
-        const actions = makeActions().flattenGatherPlan(fakePlan(), {
-            sourceId: 1,
-            destinationId: 1,
-            stratum: 100,
-        })
-        expect(actions.map((a) => a.name.toString())).toEqual([
-            'gather',
-            'gather',
-            'recharge',
-            'gather',
-        ])
-        expect(actions.filter((a) => a.name.toString() === 'recharge').length).toBe(1)
-        const gatherSlots = actions
-            .filter((a) => a.name.toString() === 'gather')
-            .map((a) => {
-                const decoded = Serializer.decode({data: a.data, type: ServerContract.Types.gather})
-                return Number(decoded.slot)
-            })
-        expect(gatherSlots).toEqual([0, 1, 0])
-    })
-
-    test('empty plan produces no actions', () => {
-        const empty = {...fakePlan(), cycles: [], cycleCount: 0, totalOre: 0}
-        expect(
-            makeActions().flattenGatherPlan(empty, {sourceId: 1, destinationId: 1, stratum: 100})
-        ).toHaveLength(0)
-    })
-})