@shipload/sdk 1.0.0-next.41 → 1.0.0-next.43

package/src/scheduling/unwrap.test.ts

@@ -0,0 +1,60 @@
+import {describe, expect, test} from 'bun:test'
+import {
+    derivedLoaders,
+    unwrapTransitDuration,
+    unwrapLoadDuration,
+    estimateUnwrapDuration,
+    incomingHoldMass,
+    projectedPeakCargomass,
+} from './unwrap'
+
+describe('unwrap duration mirror', () => {
+    test('derivedLoaders aggregates lanes like derived_loaders()', () => {
+        expect(derivedLoaders([])).toBeNull()
+        expect(
+            derivedLoaders([
+                {mass: 1000, thrust: 10},
+                {mass: 1400, thrust: 20},
+            ])
+        ).toEqual({mass: 1200, thrust: 30, quantity: 2}) // floor(2400/2)=1200, sum thrust, count
+    })
+
+    test('transit floors distance then flight time', () => {
+        // distance = floor(sqrt(3^2+4^2)*10000)=50000; accel=400/mass*10000; flight=floor(2*sqrt(d/accel))
+        const mass = 1000
+        const accel = (400 / mass) * 10000
+        const expected = Math.floor(2 * Math.sqrt(50000 / accel))
+        expect(unwrapTransitDuration(mass, {x: 0, y: 0}, {x: 3, y: 4})).toBe(expected)
+    })
+
+    test('load uses altitude z, adds loader mass, divides by quantity', () => {
+        const loaders = {mass: 1200, thrust: 30, quantity: 2}
+        const itemMass = 800
+        const accel = (30 / (itemMass + 1200)) * 10000
+        const flight = Math.floor(2 * Math.sqrt(3000 / accel))
+        expect(unwrapLoadDuration(loaders, itemMass, 3000)).toBe(Math.floor(flight / 2))
+    })
+
+    test('zero item mass and no loaders are safe', () => {
+        expect(unwrapTransitDuration(0, {x: 0, y: 0}, {x: 9, y: 9})).toBe(0)
+        expect(unwrapLoadDuration(null, 500, 3000)).toBe(0)
+    })
+})
+
+test('incomingHoldMass sums incoming-kind hold mass', () => {
+    expect(incomingHoldMass([])).toBe(0)
+    // PUSH(2) + FLIGHT(5) count; BUILD(4) does not
+    expect(
+        incomingHoldMass([
+            {kind: 2, incoming_mass: 100},
+            {kind: 4, incoming_mass: 999},
+            {kind: 5, incoming_mass: 50},
+        ])
+    ).toBe(150)
+})
+
+test('projectedPeakCargomass tracks the running peak from cargomass', () => {
+    const entity = {cargomass: 1000, lanes: [], cargo: [], schedule: undefined} as never
+    // No pending tasks: peak = base + candidate add.
+    expect(projectedPeakCargomass(entity, new Date(0), 500)).toBe(1500)
+})

package/src/scheduling/unwrap.ts

@@ -0,0 +1,187 @@
+import type {UInt16Type, UInt32Type} from '@wharfkit/antelope'
+import {calcCargoItemMass} from '../capabilities/storage'
+import type {ServerContract} from '../contracts'
+import {PRECISION} from '../types'
+import * as sched from './schedule'
+import {taskCargoEffect} from './availability'
+import {candidateLaneCompletesAt} from './lanes'
+
+const NFT_TRANSIT_THRUST = 400
+
+export interface DerivedLoaders {
+    mass: number
+    thrust: number
+    quantity: number
+}
+
+export function derivedLoaders(
+    lanes: {mass: UInt32Type | number; thrust: UInt16Type | number}[] | undefined
+): DerivedLoaders | null {
+    if (!lanes || lanes.length === 0) return null
+    let totalMass = 0
+    let totalThrust = 0
+    for (const l of lanes) {
+        totalMass += Number(l.mass)
+        totalThrust += Number(l.thrust)
+    }
+    const count = lanes.length
+    return {
+        mass: Math.floor(totalMass / count),
+        thrust: Math.min(totalThrust, 65_535),
+        quantity: count,
+    }
+}
+
+function acceleration(thrust: number, mass: number): number {
+    if (mass <= 0) return 0
+    return (thrust / mass) * PRECISION
+}
+
+function flightTime(distance: number, accel: number): number {
+    if (accel <= 0 || distance <= 0) return 0
+    return Math.floor(2 * Math.sqrt(distance / accel))
+}
+
+function distance2d(ax: number, ay: number, bx: number, by: number): number {
+    const dx = ax - bx
+    const dy = ay - by
+    return Math.floor(Math.sqrt(dx * dx + dy * dy) * PRECISION)
+}
+
+export function unwrapTransitDuration(
+    itemMass: number,
+    origin: {x: number; y: number},
+    dest: {x: number; y: number}
+): number {
+    if (itemMass <= 0) return 0
+    return flightTime(
+        distance2d(origin.x, origin.y, dest.x, dest.y),
+        acceleration(NFT_TRANSIT_THRUST, itemMass)
+    )
+}
+
+export function unwrapLoadDuration(
+    loaders: DerivedLoaders | null,
+    itemMass: number,
+    destZ: number
+): number {
+    if (!loaders || itemMass <= 0) return 0
+    const total = itemMass + loaders.mass
+    const flight = flightTime(destZ, acceleration(loaders.thrust, total))
+    return Math.floor(flight / loaders.quantity)
+}
+
+export interface UnwrapItem {
+    itemId: number
+    quantity: number
+    modules: ServerContract.Types.module_entry[]
+    originX: number
+    originY: number
+}
+
+export interface UnwrapDestination {
+    loader_lanes?: {mass: UInt32Type | number; thrust: UInt16Type | number}[]
+    coordinates: {x: UInt32Type | number; y: UInt32Type | number; z?: UInt32Type | number}
+}
+
+export function estimateUnwrapDuration(dest: UnwrapDestination, item: UnwrapItem): number {
+    const itemMass = Number(
+        calcCargoItemMass({
+            item_id: item.itemId as never,
+            quantity: item.quantity as never,
+            modules: item.modules,
+        })
+    )
+    const loaders = derivedLoaders(dest.loader_lanes)
+    const dz = Number(dest.coordinates.z ?? 0)
+    const load = unwrapLoadDuration(loaders, itemMass, dz)
+    const transit = unwrapTransitDuration(
+        itemMass,
+        {x: item.originX, y: item.originY},
+        {
+            x: Number(dest.coordinates.x),
+            y: Number(dest.coordinates.y),
+        }
+    )
+    return load + transit
+}
+
+// Hold kinds that count as incoming (mirror is_incoming_hold_kind in holds.hpp).
+const INCOMING_HOLD_KINDS = new Set<number>([2, 3, 5])
+
+export function incomingHoldMass(
+    holds:
+        | {kind: number | {toNumber(): number}; incoming_mass: number | {toNumber(): number}}[]
+        | undefined
+): number {
+    if (!holds) return 0
+    let total = 0
+    for (const h of holds) {
+        if (INCOMING_HOLD_KINDS.has(Number(h.kind))) total += Number(h.incoming_mass)
+    }
+    return total
+}
+
+type CargoItem = ServerContract.Types.cargo_item
+
+function cargoListMass(items: CargoItem[]): number {
+    let m = 0
+    for (const it of items) m += Number(calcCargoItemMass(it))
+    return m
+}
+
+export function projectedPeakCargomass(
+    entity: sched.ScheduleData & {cargomass: number | {toNumber(): number}},
+    at: Date,
+    addMass: number,
+    removeMass = 0
+): number {
+    const events: {t: number; delta: number}[] = []
+    for (const ordered of sched.orderedTasks(entity)) {
+        const eff = taskCargoEffect(ordered.task)
+        const delta = cargoListMass(eff.added) - cargoListMass(eff.removed)
+        events.push({t: ordered.completesAt.getTime(), delta})
+    }
+    events.push({t: at.getTime(), delta: addMass - removeMass})
+    events.sort((a, b) => (a.t !== b.t ? a.t - b.t : b.delta - a.delta))
+    let running = Number(entity.cargomass)
+    let peak = running
+    for (const e of events) {
+        running += e.delta
+        if (running < 0) running = 0
+        if (running > peak) peak = running
+    }
+    return Math.min(peak, 0xffff_ffff)
+}
+
+export function receiveFits(
+    dest: UnwrapDestination &
+        sched.ScheduleData & {
+            cargomass: number | {toNumber(): number}
+            capacity?: number | {toNumber(): number}
+            holds?: {
+                kind: number | {toNumber(): number}
+                incoming_mass: number | {toNumber(): number}
+            }[]
+        },
+    item: UnwrapItem,
+    now: Date
+): boolean {
+    const capacity = Number(dest.capacity ?? 0)
+    if (capacity <= 0) return false
+    const itemMass = Number(
+        calcCargoItemMass({
+            item_id: item.itemId as never,
+            quantity: item.quantity as never,
+            modules: item.modules,
+        })
+    )
+    const duration = estimateUnwrapDuration(dest, item)
+    const candidateCompletes = candidateLaneCompletesAt(dest, sched.LANE_MOBILITY, duration, now)
+    const peak = projectedPeakCargomass(
+        dest,
+        candidateCompletes,
+        itemMass + incomingHoldMass(dest.holds)
+    )
+    return peak <= capacity
+}

package/src/travel/route-planner.ts

@@ -169,9 +169,38 @@ function reconstruct(cameFrom: Map<string, Coord>, origin: Coord, dest: Coord):
     return {ok: true, waypoints, legs: waypoints.length, totalDistance}
 }
 
+export interface ScanProvider {
+    getLocationType(seedHex: string, x: number, y: number): number
+    systemsInBox(
+        seedHex: string,
+        xMin: number,
+        yMin: number,
+        xMax: number,
+        yMax: number
+    ): {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()
+}
+
 export function sdkSystemGraph(seed: Checksum256Type): SystemGraph {
     const s = Checksum256.from(seed)
-    // Travelable nodes mirror the contract's is_travelable: systems plus wormhole mouths.
+    const seedHex = s.toString()
+    const cached = graphCache.get(seedHex)
+    if (cached) return cached
+    const graph = scanProvider ? wasmSystemGraph(s, seedHex, scanProvider) : jsSystemGraph(s)
+    graphCache.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) => {
@@ -194,3 +223,55 @@ export function sdkSystemGraph(seed: Checksum256Type): SystemGraph {
         },
     }
 }
+
+const SCAN_BUCKET = 48
+
+function wasmSystemGraph(s: Checksum256, seedHex: string, scan: ScanProvider): SystemGraph {
+    // Per-bucket system cache: reused across the overlapping node queries A* makes (and across routes).
+    const bucketCache = new Map<string, {x: number; y: number}[]>()
+    const bucketSystems = (bx: number, by: number): {x: number; y: number}[] => {
+        const k = `${bx},${by}`
+        let v = bucketCache.get(k)
+        if (v === undefined) {
+            const xMin = bx * SCAN_BUCKET
+            const yMin = by * SCAN_BUCKET
+            v = scan
+                .systemsInBox(seedHex, xMin, yMin, xMin + SCAN_BUCKET - 1, yMin + SCAN_BUCKET - 1)
+                .map((cell) => ({x: cell.x, y: cell.y}))
+            bucketCache.set(k, v)
+        }
+        return v
+    }
+    return {
+        hasSystem: (c) =>
+            scan.getLocationType(seedHex, c.x, c.y) !== 0 || wormholeAt(s, c.x, c.y) !== null,
+        nearby: (c, reachTiles) => {
+            const r = Math.floor(reachTiles)
+            const seen = new Set<string>([`${c.x},${c.y}`])
+            const out: Neighbor[] = []
+            const bx0 = Math.floor((c.x - r) / SCAN_BUCKET)
+            const bx1 = Math.floor((c.x + r) / SCAN_BUCKET)
+            const by0 = Math.floor((c.y - r) / SCAN_BUCKET)
+            const by1 = Math.floor((c.y + r) / SCAN_BUCKET)
+            for (let bx = bx0; bx <= bx1; bx++) {
+                for (let by = by0; by <= by1; by++) {
+                    for (const cell of bucketSystems(bx, by)) {
+                        const dist = Math.hypot(cell.x - c.x, cell.y - c.y)
+                        if (dist > reachTiles) continue
+                        const k = `${cell.x},${cell.y}`
+                        if (seen.has(k)) continue
+                        seen.add(k)
+                        out.push({coord: {x: cell.x, y: cell.y}, dist})
+                    }
+                }
+            }
+            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
+        },
+    }
+}