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

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@shipload/sdk",
     "description": "SDKs for Shipload",
-    "version": "1.0.0-next.41",
+    "version": "1.0.0-next.42",
     "homepage": "https://github.com/shipload/toolkit/tree/master/packages/sdk",
     "repository": {
         "type": "git",

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/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

@@ -44,6 +44,38 @@ function ex(): any {
 
 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
@@ -87,32 +119,55 @@ export function systemsInBox(
     xMax: number,
     yMax: number
 ): SystemCell[] {
-    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 * 12)
-    let n = e.systems_in_box(g, xMin, yMin, xMax, yMax, out, cap)
-    if (n < 0) {
-        e.free(out)
-        cap = -n
-        out = e.malloc(cap * 12)
-        n = e.systems_in_box(g, xMin, yMin, xMax, yMax, out, cap)
-    }
-    const res: SystemCell[] = []
-    const dv = new DataView(mem.buffer.slice(out, out + n * 12))
-    for (let i = 0; i < n; i++) {
-        const o = i * 12
-        res.push({
-            x: dv.getInt32(o, true),
-            y: dv.getInt32(o + 4, true),
-            locType: dv.getUint32(o + 8, true),
-        })
-    }
-    e.free(g)
-    e.free(out)
-    return res
+    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(
@@ -121,6 +176,15 @@ export async function scanCells(
     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) => {
@@ -146,9 +210,8 @@ export async function scanCells(
         depOut = e.malloc(cap * 40)
         n = e.scan_cells(gp, ep, cp, cells.length, locOut, depOut, cap)
     }
-    const locView = new DataView(mem.buffer.slice(locOut, locOut + cells.length * 8))
-    const depView = new DataView(mem.buffer.slice(depOut, depOut + n * 40))
-    for (const p of [gp, ep, cp, locOut, depOut]) e.free(p)
+    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,
@@ -176,5 +239,6 @@ export async function scanCells(
             ],
         })
     }
+    for (const p of [gp, ep, cp, locOut, depOut]) e.free(p)
     return out
 }