@shipload/sdk 1.0.0-next.40 → 1.0.0-next.42

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@shipload/sdk",
     "description": "SDKs for Shipload",
-    "version": "1.0.0-next.40",
+    "version": "1.0.0-next.42",
     "homepage": "https://github.com/shipload/toolkit/tree/master/packages/sdk",
     "repository": {
         "type": "git",
@@ -24,6 +24,11 @@
             "import": "./lib/testing.m.js",
             "require": "./lib/testing.js"
         },
+        "./scan": {
+            "types": "./lib/scan.d.ts",
+            "import": "./lib/scan.m.js",
+            "require": "./lib/scan.js"
+        },
         "./package.json": "./package.json"
     },
     "files": [

package/src/data/recipes.json

@@ -376,7 +376,7 @@
         "quantity": 300
       },
       {
-        "itemId": 10006,
+        "itemId": 10010,
         "quantity": 300
       }
     ],

package/src/derivation/capabilities.test.ts

@@ -21,8 +21,8 @@ import {
 import type {InstalledModule} from '../entities/slot-multiplier'
 import type {EntitySlot} from '../data/recipes-runtime'
 
-function makeGathererStats(strength: number, tolerance: number, conductivity: number): bigint {
-    return encodeStats([strength, tolerance, conductivity, 0])
+function makeGathererStats(strength: number, tolerance: number, saturation: number): bigint {
+    return encodeStats([strength, tolerance, saturation, 0])
 }
 
 function makeCrafterStats(reactivity: number, conductivity: number): bigint {
@@ -72,8 +72,8 @@ test('computeEntityCapabilities emits gathererLanes alongside legacy gatherer su
     expect(result.gathererLanes![1].slotIndex).toBe(1)
 
     // Yields are amp-scaled and distinct
-    const caps1 = computeGathererCapabilities({strength: 300, tolerance: 200, conductivity: 400}, 1)
-    const caps2 = computeGathererCapabilities({strength: 500, tolerance: 100, conductivity: 300}, 1)
+    const caps1 = computeGathererCapabilities({strength: 300, tolerance: 200, saturation: 400}, 1)
+    const caps2 = computeGathererCapabilities({strength: 500, tolerance: 100, saturation: 300}, 1)
     const expectedYield1 = applySlotMultiplier(caps1.yield, 100)
     const expectedYield2 = applySlotMultiplier(caps2.yield, 100)
     expect(result.gathererLanes![0].yield).toBe(expectedYield1)

package/src/derivation/capabilities.ts

@@ -77,7 +77,7 @@ export function computeGathererCapabilities(
     depth: number
 } {
     const str = stats.strength
-    const con = stats.conductivity
+    const con = stats.saturation
     const tol = stats.tolerance
 
     return {

package/src/derivation/recipe-usage.test.ts

@@ -26,14 +26,12 @@ test('getRecipeConsumers lists every recipe that consumes Sensor', () => {
     const consumers = getRecipeConsumers(ITEM_SENSOR)
     const ids = consumers.map((c) => c.outputItemId).sort((a, b) => a - b)
     expect(ids).toEqual(
-        [ITEM_GATHERER_T1, ITEM_CRAFTER_T1, ITEM_SHIP_T1_PACKED, ITEM_EXTRACTOR_T1_PACKED].sort(
-            (a, b) => a - b
-        )
+        [ITEM_CRAFTER_T1, ITEM_SHIP_T1_PACKED, ITEM_EXTRACTOR_T1_PACKED].sort((a, b) => a - b)
     )
 })
 
-test('Sensor feeds the gatherer drain stat', () => {
-    const consumers = getRecipeConsumers(ITEM_SENSOR)
+test('Resin feeds the gatherer drain stat', () => {
+    const consumers = getRecipeConsumers(ITEM_RESIN)
     const gatherer = consumers.find((c) => c.outputItemId === ITEM_GATHERER_T1)
     expect(gatherer).toBeDefined()
     const drain = gatherer?.statFlows.find(
@@ -58,11 +56,12 @@ test('getResourceDemand traces a dual-resource component to both resources', ()
 })
 
 test('getResourceDemand recurses through a module to raw resources', () => {
-    // Gatherer = 300 Beam (5 ore + 5 gas each) + 300 Sensor (10 crystal each)
+    // Gatherer = 300 Beam (5 ore + 5 gas each) + 300 Resin (5 biomass + 5 crystal each)
     expect(getResourceDemand(ITEM_GATHERER_T1)).toEqual({
         ore: 1500,
         gas: 1500,
-        crystal: 3000,
+        biomass: 1500,
+        crystal: 1500,
     })
 })
 
@@ -70,9 +69,9 @@ test('getResourceDemand scales by quantity', () => {
     expect(getResourceDemand(ITEM_PLATE, 3)).toEqual({ore: 30})
 })
 
-test('getComponentDemand reports Resin as consumed by exactly one recipe', () => {
+test('getComponentDemand reports Resin as consumed by two recipes', () => {
     const demand = getComponentDemand()
     const resin = demand.find((d) => d.itemId === ITEM_RESIN)
     expect(resin).toBeDefined()
-    expect(resin?.consumerCount).toBe(1)
+    expect(resin?.consumerCount).toBe(2)
 })

package/src/derivation/resources.ts

@@ -15,8 +15,8 @@ export const DEPTH_THRESHOLD_T10 = 63000
 export const LOCATION_MIN_DEPTH = 500
 export const LOCATION_MAX_DEPTH = 65535
 
-export const YIELD_FRACTION_SHALLOW = 0.005
-export const YIELD_FRACTION_DEEP = 0.001
+export const YIELD_FRACTION_SHALLOW = 0.002
+export const YIELD_FRACTION_DEEP = 0.0004
 
 export function yieldThresholdAt(stratum: number): number {
     const clamped = stratum > 65535 ? 65535 : stratum

package/src/derivation/wormhole.ts

@@ -1,5 +1,6 @@
 import type {Checksum256Type} from '@wharfkit/antelope'
 import {hash512} from '../utils/hash'
+import {COORD_MAX, COORD_MIN} from '../coordinates/constants'
 
 export const WH = {
     RSIZE: 75,
@@ -72,6 +73,9 @@ function endpointInRegion(seed: Checksum256Type, R: Region, key: string): {x: nu
 function dist(a: {x: number; y: number}, b: {x: number; y: number}): number {
     return Math.sqrt((a.x - b.x) ** 2 + (a.y - b.y) ** 2)
 }
+function inBounds(c: {x: number; y: number}): boolean {
+    return c.x >= COORD_MIN && c.x <= COORD_MAX && c.y >= COORD_MIN && c.y <= COORD_MAX
+}
 function wormholeOfRegion(
     seed: Checksum256Type,
     R: Region
@@ -82,6 +86,7 @@ function wormholeOfRegion(
     if (roll16(seed, `wh-exists-${key}`) >= WH.THRESHOLD) return null
     const A = endpointInRegion(seed, R, key)
     const B = endpointInRegion(seed, P, key)
+    if (!inBounds(A) || !inBounds(B)) return null
     if (dist(A, B) < WH.MIN_REACH) return null
     return {A, B}
 }

package/src/index-module.ts

@@ -50,6 +50,7 @@ export {
     ConstructionManager,
 } from './managers'
 export type {
+    PlayerRosterEntry,
     LocationStratum,
     NftConfigForItem,
     BuildableTarget,
@@ -206,11 +207,12 @@ export type {
     HasScheduleAndLocation,
 } from './travel/travel'
 
-export {planRoute, sdkSystemGraph, MAX_LEGS} from './travel/route-planner'
+export {planRoute, sdkSystemGraph, setScanProvider, MAX_LEGS} from './travel/route-planner'
 export type {
     Coord,
     Neighbor,
     SystemGraph,
+    ScanProvider,
     RoutePlan,
     RouteFailure,
     RouteResult,

package/src/managers/entities.ts

@@ -34,6 +34,15 @@ export class EntitiesManager extends BaseManager {
         return entities.map((e) => new Entity(e))
     }
 
+    async getAllEntities(kind?: EntityTypeName): Promise<ServerContract.Types.entity_row[]> {
+        const rows = await this.server.table('entity').all()
+        if (!kind) {
+            return rows
+        }
+        const wanted = Name.from(kind)
+        return rows.filter((row) => wanted.equals(row.kind))
+    }
+
     async getSummaries(
         owner: NameType | ServerContract.Types.player_row,
         kind?: EntityTypeName

package/src/managers/index.ts

@@ -3,6 +3,7 @@ export {BaseManager} from './base'
 export {EntitiesManager} from './entities'
 export type {EntityTypeName} from './entities'
 export {PlayersManager} from './players'
+export type {PlayerRosterEntry} from './players'
 export {LocationsManager} from './locations'
 export type {LocationStratum} from './locations'
 export {EpochsManager} from './epochs'

package/src/managers/players.ts

@@ -2,6 +2,11 @@ import {Name, type NameType} from '@wharfkit/antelope'
 import {BaseManager} from './base'
 import {Player} from '../entities/player'
 
+export interface PlayerRosterEntry {
+    owner: Name
+    company?: string
+}
+
 export class PlayersManager extends BaseManager {
     async getPlayer(account: NameType): Promise<Player | undefined> {
         const playerRow = await this.server.table('player').get(Name.from(account))
@@ -10,4 +15,24 @@ export class PlayersManager extends BaseManager {
         }
         return new Player(playerRow)
     }
+
+    async getPlayers(): Promise<Player[]> {
+        const rows = await this.server.table('player').all()
+        return rows.map((row) => new Player(row))
+    }
+
+    async getRoster(): Promise<PlayerRosterEntry[]> {
+        const [players, companies] = await Promise.all([
+            this.server.table('player').all(),
+            this.platform.table('company').all(),
+        ])
+        const companyNames = new Map<string, string>()
+        for (const company of companies) {
+            companyNames.set(company.account.toString(), company.name)
+        }
+        return players.map((player) => ({
+            owner: player.owner,
+            company: companyNames.get(player.owner.toString()),
+        }))
+    }
 }

package/src/nft/buildImmutableData.ts

@@ -203,8 +203,8 @@ export function buildModuleImmutable(
             const ref = decodeStat(stats, 3)
             base.push({first: 'strength', second: ['uint16', str]})
             base.push({first: 'tolerance', second: ['uint16', tol]})
-            base.push({first: 'conductivity', second: ['uint16', con]})
-            base.push({first: 'reflectivity', second: ['uint16', ref]})
+            base.push({first: 'saturation', second: ['uint16', con]})
+            base.push({first: 'plasticity', second: ['uint16', ref]})
             base.push({first: 'yield', second: ['uint16', computeGathererYield(str)]})
             base.push({first: 'drain', second: ['uint16', computeGathererDrain(con)]})
             base.push({first: 'depth', second: ['uint16', computeGathererDepth(tol, item.tier)]})

package/src/scan/index.ts

@@ -0,0 +1,244 @@
+import {SCAN_WASM_B64} from './scan-wasm.base64'
+
+const stubImports: WebAssembly.Imports = new Proxy(
+    {},
+    {
+        get: () => new Proxy({}, {get: () => () => 0}),
+    }
+) as any
+
+let inst: WebAssembly.Instance | null = null
+let readyPromise: Promise<void> | null = null
+
+function bytes(): Uint8Array {
+    return Uint8Array.from(atob(SCAN_WASM_B64), (c) => c.charCodeAt(0))
+}
+
+function finish(i: WebAssembly.Instance) {
+    const ex = i.exports as any
+    if (typeof ex._initialize === 'function') ex._initialize()
+    inst = i
+}
+
+export function scanReady(): Promise<void> {
+    if (inst) return Promise.resolve()
+    if (!readyPromise)
+        readyPromise = (
+            WebAssembly.instantiate(bytes().buffer as ArrayBuffer, stubImports) as Promise<{
+                instance: WebAssembly.Instance
+            }>
+        ).then((r) => finish(r.instance))
+    return readyPromise
+}
+
+function ex(): any {
+    if (!inst)
+        finish(
+            new WebAssembly.Instance(
+                new WebAssembly.Module(bytes().buffer as ArrayBuffer),
+                stubImports
+            )
+        )
+    return inst!.exports
+}
+
+const hex = (h: string) => Uint8Array.from(h.match(/../g)!.map((b) => parseInt(b, 16)))
+
+// Shared marshalling for the `*_in_box` exports; grow-and-retry once on overflow (export returns -needed).
+function boxScan<T>(
+    exportName: string,
+    stride: number,
+    gameSeed: string,
+    xMin: number,
+    yMin: number,
+    xMax: number,
+    yMax: number,
+    decode: (dv: DataView, o: number) => T
+): T[] {
+    const e = ex()
+    const mem = e.memory as WebAssembly.Memory
+    const g = e.malloc(32)
+    new Uint8Array(mem.buffer, g, 32).set(hex(gameSeed))
+    let cap = 256
+    let out = e.malloc(cap * stride)
+    let n = e[exportName](g, xMin, yMin, xMax, yMax, out, cap)
+    if (n < 0) {
+        e.free(out)
+        cap = -n
+        out = e.malloc(cap * stride)
+        n = e[exportName](g, xMin, yMin, xMax, yMax, out, cap)
+    }
+    const dv = new DataView(mem.buffer, out, n * stride)
+    const res: T[] = []
+    for (let i = 0; i < n; i++) res.push(decode(dv, i * stride))
+    e.free(g)
+    e.free(out)
+    return res
+}
+
+export function getLocationType(gameSeed: string, x: number, y: number): number {
+    const e = ex()
+    const mem = e.memory as WebAssembly.Memory
+    const g = e.malloc(32)
+    new Uint8Array(mem.buffer, g, 32).set(hex(gameSeed))
+    const t = e.get_location_type(g, BigInt(x), BigInt(y))
+    e.free(g)
+    return t
+}
+
+export interface SystemCell {
+    x: number
+    y: number
+    locType: number
+}
+
+export interface Coord {
+    x: number
+    y: number
+}
+
+export interface Deposit {
+    x: number
+    y: number
+    depth: number
+    itemId: number
+    richness: number
+    reserve: number
+    stats: [number, number, number]
+}
+
+export interface DerivedCell {
+    location: {x: number; y: number; locType: number; subtype: number; size: number}
+    deposits: Deposit[]
+}
+
+export function systemsInBox(
+    gameSeed: string,
+    xMin: number,
+    yMin: number,
+    xMax: number,
+    yMax: number
+): SystemCell[] {
+    return boxScan('systems_in_box', 12, gameSeed, xMin, yMin, xMax, yMax, (dv, o) => ({
+        x: dv.getInt32(o, true),
+        y: dv.getInt32(o + 4, true),
+        locType: dv.getUint32(o + 8, true),
+    }))
+}
+
+export interface LocationCell {
+    x: number
+    y: number
+    locType: number
+    subtype: number
+    size: number
+}
+
+export function locationsInBox(
+    gameSeed: string,
+    xMin: number,
+    yMin: number,
+    xMax: number,
+    yMax: number
+): LocationCell[] {
+    return boxScan('locations_in_box', 16, gameSeed, xMin, yMin, xMax, yMax, (dv, o) => ({
+        x: dv.getInt32(o, true),
+        y: dv.getInt32(o + 4, true),
+        locType: dv.getUint8(o + 8),
+        subtype: dv.getUint8(o + 9),
+        size: dv.getUint32(o + 12, true),
+    }))
+}
+
+export interface WormholeCell {
+    x: number
+    y: number
+    exit: {x: number; y: number}
+}
+
+export function wormholesInBox(
+    gameSeed: string,
+    xMin: number,
+    yMin: number,
+    xMax: number,
+    yMax: number
+): WormholeCell[] {
+    return boxScan('wormholes_in_box', 16, gameSeed, xMin, yMin, xMax, yMax, (dv, o) => ({
+        x: dv.getInt32(o, true),
+        y: dv.getInt32(o + 4, true),
+        exit: {x: dv.getInt32(o + 8, true), y: dv.getInt32(o + 12, true)},
+    }))
+}
+
+export async function scanCells(
+    gameSeed: string,
+    epochSeed: string,
+    cells: Coord[]
+): Promise<DerivedCell[]> {
+    await scanReady()
+    return scanCellsCore(gameSeed, epochSeed, cells)
+}
+
+// Sync sibling of scanCells; caller must warm the instance via scanReady() first.
+export function scanCellsSync(gameSeed: string, epochSeed: string, cells: Coord[]): DerivedCell[] {
+    return scanCellsCore(gameSeed, epochSeed, cells)
+}
+
+function scanCellsCore(gameSeed: string, epochSeed: string, cells: Coord[]): DerivedCell[] {
+    const e = ex()
+    const mem = e.memory as WebAssembly.Memory
+    const write = (b: Uint8Array) => {
+        const p = e.malloc(b.length)
+        new Uint8Array(mem.buffer, p, b.length).set(b)
+        return p
+    }
+    const gp = write(hex(gameSeed))
+    const ep = write(hex(epochSeed))
+    const cellArr = new Int32Array(cells.length * 2)
+    cells.forEach((c, i) => {
+        cellArr[i * 2] = c.x
+        cellArr[i * 2 + 1] = c.y
+    })
+    const cp = write(new Uint8Array(cellArr.buffer))
+    const locOut = e.malloc(cells.length * 8)
+    let cap = Math.max(64, cells.length * 8)
+    let depOut = e.malloc(cap * 40)
+    let n = e.scan_cells(gp, ep, cp, cells.length, locOut, depOut, cap)
+    if (n < 0) {
+        e.free(depOut)
+        cap = -n
+        depOut = e.malloc(cap * 40)
+        n = e.scan_cells(gp, ep, cp, cells.length, locOut, depOut, cap)
+    }
+    const locView = new DataView(mem.buffer, locOut, cells.length * 8)
+    const depView = new DataView(mem.buffer, depOut, n * 40)
+    const out: DerivedCell[] = cells.map((c, i) => ({
+        location: {
+            x: c.x,
+            y: c.y,
+            locType: locView.getUint8(i * 8),
+            subtype: locView.getUint8(i * 8 + 1),
+            size: locView.getUint32(i * 8 + 4, true),
+        },
+        deposits: [],
+    }))
+    for (let i = 0; i < n; i++) {
+        const o = i * 40
+        const ci = depView.getUint32(o, true)
+        out[ci].deposits.push({
+            x: cells[ci].x,
+            y: cells[ci].y,
+            depth: depView.getUint32(o + 4, true),
+            itemId: depView.getUint32(o + 8, true),
+            richness: depView.getUint32(o + 12, true),
+            reserve: depView.getFloat64(o + 32, true),
+            stats: [
+                depView.getUint32(o + 16, true),
+                depView.getUint32(o + 20, true),
+                depView.getUint32(o + 24, true),
+            ],
+        })
+    }
+    for (const p of [gp, ep, cp, locOut, depOut]) e.free(p)
+    return out
+}