@shipload/sdk 1.0.0-next.50 → 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

@@ -0,0 +1,170 @@
+import type {UInt64Type} from '@wharfkit/antelope'
+import {PRECISION, TRAVEL_MAX_DURATION} from '../types'
+import {
+    calc_energyusage,
+    calc_group_flighttime,
+    calc_rechargetime,
+    distanceBetweenPoints,
+} from './travel'
+
+export interface RouteMoverInput {
+    ref: {entityType: string; entityId: UInt64Type}
+    hasMovement: boolean
+    engines?: {thrust: number; drain: number}
+    generator?: {capacity: number; recharge: number}
+    hauler?: {capacity: number; efficiency: number}
+    mass: number
+    energy: number
+    priorMobilityEnd: number
+    narrowBarrierEnd: number
+    /** Max end (seconds-from-now) over all this entity's lanes incl. worker/craft; gates recharges like the contract's all_lanes_end. Default 0. */
+    allLanesEnd?: number
+}
+
+export interface RouteLegSim {
+    from: {x: number; y: number}
+    to: {x: number; y: number}
+    distanceCells: number
+    energyCostByMover: Record<string, number>
+    rechargeBefore: boolean
+    rechargeSeconds: number
+    flightSeconds: number
+}
+
+export interface RouteSim {
+    legs: RouteLegSim[]
+    totalSeconds: number
+    reachable: boolean
+}
+
+export function simulateRoute(
+    movers: RouteMoverInput[],
+    waypoints: {x: number; y: number}[],
+    origin: {x: number; y: number},
+    recharge: boolean
+): RouteSim {
+    const totalThrust = movers
+        .filter((m) => m.hasMovement && m.engines)
+        .reduce((sum, m) => sum + m.engines!.thrust, 0)
+
+    const totalMass = movers.reduce((sum, m) => sum + m.mass, 0)
+
+    const haulCount = movers.filter((m) => !m.hasMovement).length
+
+    const pooledHaulCap = movers
+        .filter((m) => m.hasMovement && m.hauler)
+        .reduce((sum, m) => sum + m.hauler!.capacity, 0)
+
+    const weightedHaulEffNum = movers
+        .filter((m) => m.hasMovement && m.hauler)
+        .reduce((sum, m) => sum + m.hauler!.efficiency * m.hauler!.capacity, 0)
+
+    const energyByMover: Map<string, number> = new Map(
+        movers.map((m) => [String(m.ref.entityId), m.energy])
+    )
+
+    let reachable = true
+    const legs: RouteLegSim[] = []
+
+    const mobilityBarrier = movers
+        .filter((m) => m.hasMovement)
+        .reduce((mx, m) => Math.max(mx, m.priorMobilityEnd, m.narrowBarrierEnd), 0)
+
+    const rechargeFloor = movers
+        .filter((m) => m.hasMovement && m.generator)
+        .reduce((mx, m) => Math.max(mx, m.allLanesEnd ?? 0), 0)
+
+    let clock = 0
+
+    let from = origin
+    for (const to of waypoints) {
+        const distance = distanceBetweenPoints(from.x, from.y, to.x, to.y)
+        const distanceNum = Number(distance)
+        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)
+            energyCostByMover[key] = Number(calc_energyusage(distance, m.engines.drain))
+        }
+
+        let rechargeBefore = false
+        let rechargeSeconds = 0
+
+        if (recharge) {
+            let maxDur = 0
+            for (const m of movers) {
+                if (!m.hasMovement || !m.generator) continue
+                const key = String(m.ref.entityId)
+                const curEnergy = energyByMover.get(key) ?? 0
+                const dur = Number(
+                    calc_rechargetime(m.generator.capacity, curEnergy, m.generator.recharge)
+                )
+                if (dur > maxDur) maxDur = dur
+            }
+            rechargeSeconds = maxDur
+            rechargeBefore = rechargeSeconds > 0
+
+            if (rechargeBefore) {
+                for (const m of movers) {
+                    if (!m.hasMovement || !m.generator) continue
+                    const key = String(m.ref.entityId)
+                    energyByMover.set(key, m.generator.capacity)
+                }
+                clock = Math.max(clock, rechargeFloor) + rechargeSeconds
+            }
+        }
+
+        for (const m of movers) {
+            if (!m.hasMovement || !m.engines) continue
+            const key = String(m.ref.entityId)
+            const cost = energyCostByMover[key] ?? 0
+            const curEnergy = energyByMover.get(key) ?? 0
+
+            if (recharge && m.generator) {
+                if (cost > m.generator.capacity) reachable = false
+            } else {
+                if (cost > curEnergy) reachable = false
+            }
+        }
+
+        const flightSeconds = Number(
+            calc_group_flighttime(
+                totalThrust,
+                haulCount,
+                pooledHaulCap,
+                weightedHaulEffNum,
+                totalMass,
+                distance
+            )
+        )
+
+        if (flightSeconds > TRAVEL_MAX_DURATION) reachable = false
+
+        for (const m of movers) {
+            if (!m.hasMovement || !m.engines) continue
+            const key = String(m.ref.entityId)
+            const cost = energyCostByMover[key] ?? 0
+            const curEnergy = energyByMover.get(key) ?? 0
+            energyByMover.set(key, Math.max(0, curEnergy - cost))
+        }
+
+        clock = Math.max(clock, mobilityBarrier) + flightSeconds
+
+        legs.push({
+            from,
+            to,
+            distanceCells,
+            energyCostByMover,
+            rechargeBefore,
+            rechargeSeconds,
+            flightSeconds,
+        })
+
+        from = to
+    }
+
+    return {legs, totalSeconds: clock, reachable}
+}

package/src/travel/travel.ts

@@ -14,7 +14,6 @@ import {
     type Checksum256,
     Int64,
     type Int64Type,
-    UInt16,
     UInt32,
     type UInt32Type,
     UInt64,
@@ -23,9 +22,11 @@ import {
 
 import type {ServerContract} from '../contracts'
 import {
+    BASE_HAUL_PENALTY_MILLI,
     BASE_ORBITAL_MASS,
     type CargoMassInfo,
     type Distance,
+    HAULER_EFFICIENCY_DENOM,
     MAX_ORBITAL_ALTITUDE,
     MIN_ORBITAL_ALTITUDE,
     MIN_TRANSFER_DISTANCE_ORBITAL_VESSEL,
@@ -187,14 +188,15 @@ export function calc_rechargetime(
     const cap = UInt32.from(capacity)
     const eng = UInt32.from(energy)
     if (eng.gte(cap)) return UInt32.zero
-    return cap.subtracting(eng).dividing(recharge)
+    const ticks = cap.subtracting(eng).dividing(recharge)
+    return ticks.equals(UInt32.zero) ? UInt32.from(1) : ticks
 }
 
 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
     )
 }
@@ -203,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)))
@@ -232,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 {
@@ -263,8 +275,31 @@ export function calc_ship_mass(ship: ShipLike, cargos: CargoMassInfo[]): UInt64
     return mass
 }
 
+export function calc_group_flighttime(
+    totalThrust: number,
+    haulCount: number,
+    pooledHaulCap: number,
+    weightedHaulEffNum: number,
+    totalMass: number,
+    distance: UInt64Type
+): UInt32 {
+    const avgHaulEff = pooledHaulCap > 0 ? Math.trunc(weightedHaulEffNum / pooledHaulCap) : 0
+    let effectiveThrust = totalThrust
+    if (haulCount > 0) {
+        const penaltyMilli =
+            1000 +
+            Math.trunc(
+                (haulCount * BASE_HAUL_PENALTY_MILLI * (HAULER_EFFICIENCY_DENOM - avgHaulEff)) /
+                    HAULER_EFFICIENCY_DENOM
+            )
+        effectiveThrust = Math.trunc((totalThrust * 1000) / penaltyMilli)
+    }
+    const acceleration = calc_acceleration(effectiveThrust, totalMass)
+    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

@@ -18,6 +18,9 @@ export const CONTAINER_Z = 300
 
 export const TRAVEL_MAX_DURATION = 86400
 
+export const BASE_HAUL_PENALTY_MILLI = 300
+export const HAULER_EFFICIENCY_DENOM = 10000
+
 export const MIN_ORBITAL_ALTITUDE = 800
 export const MAX_ORBITAL_ALTITUDE = 3000
 
@@ -35,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[]
@@ -57,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 {
@@ -73,6 +76,7 @@ export enum HoldKind {
     PUSH = 2,
     GATHER = 3,
     BUILD = 4,
+    FLIGHT = 5,
     UPGRADE = 6,
 }
 
@@ -135,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)
-    })
-})