@shipload/sdk 1.0.0-next.6 → 1.0.0-next.61

package/src/resolution/resolve-item.ts

@@ -1,14 +1,17 @@
 import {UInt16, UInt64} from '@wharfkit/antelope'
 import type {UInt16Type, UInt64Type} from '@wharfkit/antelope'
 import type {ResourceCategory} from '../types'
-import {getItem} from '../data/catalog'
+import {getItem, getModules} from '../data/catalog'
+import {ENTITY_SHIP, getPackedEntityType} from '../data/kind-registry'
 import {getEntityLayout} from '../data/recipes-runtime'
 import {entityMetadata, itemMetadata} from '../data/metadata'
 import {
     getModuleCapabilityType,
     isModuleItem,
+    MODULE_BUILDER,
     MODULE_CRAFTER,
     MODULE_ENGINE,
+    MODULE_BATTERY,
     MODULE_GATHERER,
     MODULE_GENERATOR,
     MODULE_HAULER,
@@ -19,29 +22,21 @@ import {decodeCraftedItemStats, decodeStat} from '../derivation/crafting'
 import {getStatDefinitions} from '../derivation/stats'
 import {
     computeCrafterCapabilities,
+    computeBuilderCapabilities,
+    computeBatteryCapabilities,
     computeEngineCapabilities,
     computeGathererCapabilities,
     computeGeneratorCapabilities,
     computeHaulerCapabilities,
     computeLoaderCapabilities,
-    computeShipHullCapabilities,
-    computeWarehouseHullCapabilities,
-} from '../entities/ship-deploy'
-import {computeContainerCapabilities, computeContainerT2Capabilities} from '../entities/container'
-import {
-    categoryColors,
-    categoryIcons,
-    componentIcon,
-    itemAbbreviations,
-    moduleIcon,
-} from '../data/colors'
+    computeBaseCapacity,
+    computeBaseHullmass,
+    computeStorageCapabilities,
+} from '../derivation/capabilities'
+import {applySlotMultiplierUint32} from '../entities/slot-multiplier'
+import {toWholeEnergy} from '../nft/description'
+import {categoryColors, componentIcon, itemAbbreviations, moduleIcon} from '../data/colors'
 import type {ServerContract} from '../contracts'
-import {
-    ITEM_CONTAINER_T1_PACKED,
-    ITEM_CONTAINER_T2_PACKED,
-    ITEM_SHIP_T1_PACKED,
-    ITEM_WAREHOUSE_T1_PACKED,
-} from '../data/item-ids'
 
 export interface ResolvedItemStat {
     key: string
@@ -62,8 +57,13 @@ export type ResolvedItemType = 'resource' | 'component' | 'module' | 'entity'
 
 export interface ResolvedModuleSlot {
     name?: string
+    capability?: string
     installed: boolean
     attributes?: {label: string; value: number}[]
+    slotLabel?: string
+    slotType?: string
+    outputPct?: number
+    maxTier?: number
 }
 
 export interface ResolvedItem {
@@ -109,7 +109,7 @@ function resolveResource(id: number, stats?: UInt64Type): ResolvedItem {
     return {
         itemId: id,
         name: item.name,
-        icon: cat ? categoryIcons[cat] : '⬡',
+        icon: '',
         abbreviation: null,
         category: cat,
         tier: item.tier,
@@ -156,11 +156,12 @@ function resolveComponent(id: number, stats?: UInt64Type): ResolvedItem {
 function computeCapabilityGroup(
     moduleType: number,
     stats: Record<string, number>,
-    tier: number
+    tier: number,
+    outputPct = 100
 ): ResolvedAttributeGroup | undefined {
     switch (moduleType) {
         case MODULE_ENGINE: {
-            const caps = computeEngineCapabilities(stats)
+            const caps = computeEngineCapabilities(stats, tier)
             return {
                 capability: 'Engine',
                 attributes: [
@@ -170,12 +171,12 @@ function computeCapabilityGroup(
             }
         }
         case MODULE_GENERATOR: {
-            const caps = computeGeneratorCapabilities(stats)
+            const caps = computeGeneratorCapabilities(stats, tier)
             return {
                 capability: 'Generator',
                 attributes: [
-                    {label: 'Capacity', value: caps.capacity},
-                    {label: 'Recharge', value: caps.recharge},
+                    {label: 'Capacity', value: toWholeEnergy(caps.capacity)},
+                    {label: 'Recharge', value: toWholeEnergy(caps.recharge)},
                 ],
             }
         }
@@ -185,16 +186,15 @@ function computeCapabilityGroup(
                 capability: 'Gatherer',
                 attributes: [
                     {label: 'Yield', value: caps.yield},
-                    {label: 'Drain', value: caps.drain},
+                    {label: 'Drain', value: toWholeEnergy(caps.drain)},
                     {label: 'Depth', value: caps.depth},
-                    {label: 'Speed', value: caps.speed},
                 ],
             }
         }
         case MODULE_LOADER: {
-            const caps = computeLoaderCapabilities(stats)
+            const caps = computeLoaderCapabilities(stats, tier)
             return {
-                capability: 'Loader',
+                capability: 'Loading',
                 attributes: [
                     {label: 'Mass', value: caps.mass},
                     {label: 'Thrust', value: caps.thrust},
@@ -203,45 +203,82 @@ function computeCapabilityGroup(
             }
         }
         case MODULE_CRAFTER: {
-            const caps = computeCrafterCapabilities(stats)
+            const caps = computeCrafterCapabilities(stats, tier)
             return {
-                capability: 'Crafter',
+                capability: 'Crafting',
                 attributes: [
                     {label: 'Speed', value: caps.speed},
-                    {label: 'Drain', value: caps.drain},
+                    {label: 'Drain', value: toWholeEnergy(caps.drain)},
+                ],
+            }
+        }
+        case MODULE_BUILDER: {
+            const caps = computeBuilderCapabilities(stats, tier)
+            return {
+                capability: 'Build',
+                attributes: [
+                    {label: 'Speed', value: caps.speed},
+                    {label: 'Drain', value: toWholeEnergy(caps.drain)},
                 ],
             }
         }
         case MODULE_HAULER: {
-            const caps = computeHaulerCapabilities(stats)
+            const caps = computeHaulerCapabilities(stats, tier)
             return {
-                capability: 'Hauler',
+                capability: 'Hauling',
                 attributes: [
                     {label: 'Capacity', value: caps.capacity},
                     {label: 'Efficiency', value: caps.efficiency},
-                    {label: 'Drain', value: caps.drain},
+                    {label: 'Drain', value: toWholeEnergy(caps.drain)},
                 ],
             }
         }
         case MODULE_STORAGE: {
-            const str = stats.strength
-            const den = stats.density
-            const hrd = stats.hardness
-            const sat = stats.saturation
-            const statSum = str + den + hrd + sat
-            const pct = 10 + Math.floor((statSum * 10) / 2997)
-            return {capability: 'Storage', attributes: [{label: 'Capacity Bonus', value: pct}]}
+            const caps = computeStorageCapabilities(stats, tier)
+            return {
+                capability: 'Storage',
+                attributes: [
+                    {
+                        label: 'Cargo Capacity',
+                        value: applySlotMultiplierUint32(caps.capacity, outputPct),
+                    },
+                    {label: 'Drain', value: toWholeEnergy(caps.drain)},
+                ],
+            }
+        }
+        case MODULE_BATTERY: {
+            const caps = computeBatteryCapabilities(stats, tier)
+            return {
+                capability: 'Energy',
+                attributes: [
+                    {
+                        label: 'Energy Capacity',
+                        value: toWholeEnergy(applySlotMultiplierUint32(caps.capacity, outputPct)),
+                    },
+                ],
+            }
         }
         default:
             return undefined
     }
 }
 
+// Recipe-less higher-tier modules reuse the T1 stat layout of their module type.
+function decodeModuleStats(id: number, big: bigint): Record<string, number> {
+    const decoded = decodeCraftedItemStats(id, big)
+    if (Object.keys(decoded).length > 0) return decoded
+    const moduleType = getItem(id).moduleType
+    if (!moduleType) return decoded
+    const t1 = getModules({moduleType, tier: 1})[0]
+    if (!t1) return decoded
+    return decodeCraftedItemStats(Number(t1.id), big)
+}
+
 function resolveModule(id: number, stats?: UInt64Type): ResolvedItem {
     const item = getItem(id)
     let attributes: ResolvedAttributeGroup[] | undefined
     if (stats !== undefined) {
-        const decoded = decodeCraftedItemStats(id, toBigStats(stats))
+        const decoded = decodeModuleStats(id, toBigStats(stats))
         const modType = getModuleCapabilityType(id)
         const group = computeCapabilityGroup(modType, decoded, item.tier)
         if (group) attributes = [group]
@@ -260,22 +297,26 @@ function resolveModule(id: number, stats?: UInt64Type): ResolvedItem {
 
 function hullCapsForEntity(
     itemId: number,
-    decoded: Record<string, number>
+    decoded: Record<string, number>,
+    packedStats: bigint
 ): {
     hullmass: number
     capacity: number
 } {
-    switch (itemId) {
-        case ITEM_SHIP_T1_PACKED:
-            return computeShipHullCapabilities(decoded)
-        case ITEM_WAREHOUSE_T1_PACKED:
-            return computeWarehouseHullCapabilities(decoded)
-        case ITEM_CONTAINER_T1_PACKED:
-            return computeContainerCapabilities(decoded)
-        case ITEM_CONTAINER_T2_PACKED:
-            return computeContainerT2Capabilities(decoded)
-        default:
-            throw new Error(`resolveItem: no capacity formula wired for entity item ${itemId}`)
+    // A ship hull consumes all five positional packed channels. This is separate
+    // from the recipe-facing stat labels, which remain historical for Ship T1.
+    const hullStats = getPackedEntityType(itemId)?.equals(ENTITY_SHIP)
+        ? {
+              strength: decodeStat(packedStats, 0),
+              hardness: decodeStat(packedStats, 1),
+              plasticity: decodeStat(packedStats, 2),
+              volatility: decodeStat(packedStats, 3),
+              conductivity: decodeStat(packedStats, 4),
+          }
+        : decoded
+    return {
+        hullmass: computeBaseHullmass(itemId, hullStats),
+        capacity: computeBaseCapacity(itemId, hullStats),
     }
 }
 
@@ -290,8 +331,12 @@ function resolveEntity(
     let moduleSlots: ResolvedModuleSlot[] | undefined
 
     if (stats !== undefined) {
-        const decoded = decodeCraftedItemStats(id, toBigStats(stats))
-        const hullCaps = hullCapsForEntity(id, decoded)
+        const bigStats = toBigStats(stats)
+        const decoded = decodeCraftedItemStats(id, bigStats)
+        if (decoded.strength === undefined) decoded.strength = decodeStat(bigStats, 0)
+        if (decoded.density === undefined) decoded.density = decodeStat(bigStats, 1)
+        if (decoded.hardness === undefined) decoded.hardness = decodeStat(bigStats, 2)
+        const hullCaps = hullCapsForEntity(id, decoded, bigStats)
         attributes = [
             {
                 capability: 'Hull',
@@ -306,11 +351,17 @@ function resolveEntity(
     if (layout && layout.slots.length > 0) {
         const slotLabels = entityMetadata[id]?.moduleSlotLabels ?? []
         moduleSlots = layout.slots.map((slot, i) => {
+            const slotInfo = {
+                slotLabel: slotLabels[i] ?? slot.type,
+                slotType: slot.type,
+                outputPct: slot.outputPct,
+                maxTier: slot.maxTier,
+            }
             const mod = modules?.[i]
             if (mod?.installed) {
                 const modItemId = Number(mod.installed.item_id.value.toString())
                 const modStats = BigInt(mod.installed.stats.toString())
-                const decodedStats = decodeCraftedItemStats(modItemId, modStats)
+                const decodedStats = decodeModuleStats(modItemId, modStats)
                 const modType = getModuleCapabilityType(modItemId)
                 let modName = 'Module'
                 let modTier = 1
@@ -321,16 +372,19 @@ function resolveEntity(
                 } catch {
                     modName = itemMetadata[modItemId]?.name ?? 'Module'
                 }
-                const group = computeCapabilityGroup(modType, decodedStats, modTier)
+                const group = computeCapabilityGroup(modType, decodedStats, modTier, slot.outputPct)
                 return {
                     name: modName,
+                    capability: group?.capability,
                     installed: true,
                     attributes: group?.attributes,
+                    ...slotInfo,
                 }
             }
             return {
                 name: slotLabels[i] ?? slot.type,
                 installed: false,
+                ...slotInfo,
             }
         })
     }

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
+}