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

package/src/resolution/describe-module.ts

@@ -53,25 +53,22 @@ const TEMPLATES: Record<string, TemplateSpec> = {
     gatherer: {
         id: 'module.gatherer.description',
         template:
-            'mines resources at {yield} speed to a max depth of {depth} with {speed} gather speed while draining {drain} energy per second',
+            'mines resources at {yield} yield to a max depth of {depth} while draining {drain} energy per second',
         params: [
             ['yield', 'Yield'],
-            ['drain', 'Drain'],
             ['depth', 'Depth'],
-            ['speed', 'Speed'],
+            ['drain', 'Drain'],
         ],
-        highlightKeys: ['yield', 'depth', 'speed', 'drain'],
+        highlightKeys: ['yield', 'depth', 'drain'],
     },
     loader: {
         id: 'module.loader.description',
-        template:
-            '{quantity} loader that generates {thrust} thrust with a weight of {mass} per unit',
+        template: 'generates {thrust} thrust with a weight of {mass} per unit',
         params: [
-            ['quantity', 'Quantity'],
             ['thrust', 'Thrust'],
             ['mass', 'Mass'],
         ],
-        highlightKeys: ['quantity', 'thrust', 'mass'],
+        highlightKeys: ['thrust', 'mass'],
     },
     crafter: {
         id: 'module.crafter.description',
@@ -84,9 +81,15 @@ const TEMPLATES: Record<string, TemplateSpec> = {
     },
     storage: {
         id: 'module.storage.description',
-        template: 'boosts cargo capacity by {bonus}%',
-        params: [['bonus', 'Capacity Bonus']],
-        highlightKeys: ['bonus'],
+        template: 'adds {capacity} cargo capacity',
+        params: [['capacity', 'Cargo Capacity']],
+        highlightKeys: ['capacity'],
+    },
+    energy: {
+        id: 'module.energy-capacity.description',
+        template: 'adds {capacity} energy capacity',
+        params: [['capacity', 'Energy Capacity']],
+        highlightKeys: ['capacity'],
     },
     hauler: {
         id: 'module.hauler.description',
@@ -127,8 +130,10 @@ export function describeModuleForItem(resolved: ResolvedItem): ModuleDescription
 }
 
 export function describeModuleForSlot(slot: ResolvedModuleSlot): ModuleDescription | null {
-    if (!slot.installed || !slot.name || !slot.attributes) return null
-    return describeModule({capability: slot.name, attributes: slot.attributes})
+    if (!slot.installed || !slot.attributes) return null
+    const capability = slot.capability ?? slot.name
+    if (!capability) return null
+    return describeModule({capability, attributes: slot.attributes})
 }
 
 export function renderDescription(

package/src/resolution/display-name.ts

@@ -1,22 +1,50 @@
 import type {ResolvedItem} from './resolve-item'
 import type {ResourceCategory} from '../types'
-import {CATEGORY_LABELS, TIER_ADJECTIVES} from '../types'
+import {
+    CATEGORY_LABELS,
+    RESOURCE_TIER_ADJECTIVES,
+    COMPONENT_TIER_PREFIXES,
+    MODULE_TIER_PREFIXES,
+} from '../types'
 import {formatMass as defaultFormatMass} from '../format'
 
-export interface DisplayNameInput {
-    itemType: 'resource' | 'component' | 'module' | 'entity' | string
+interface DisplayNameInputCommon {
     tier: number
     category?: ResourceCategory
     name: string
 }
 
-export function displayName(resolved: DisplayNameInput): string {
-    if (resolved.itemType === 'resource') {
-        const adj = TIER_ADJECTIVES[resolved.tier] ?? 'Unknown'
-        const cat = resolved.category ? CATEGORY_LABELS[resolved.category] : 'Resource'
-        return `${adj} ${cat}`
-    }
-    return resolved.name
+export type DisplayNameInput =
+    | (DisplayNameInputCommon & {itemType: 'resource' | 'component' | 'module' | 'entity' | string})
+    | (DisplayNameInputCommon & {type: string})
+
+function itemTypeOf(item: DisplayNameInput): string {
+    return 'itemType' in item ? item.itemType : item.type
+}
+
+function tierPrefix(item: DisplayNameInput): string | null {
+    const t = itemTypeOf(item)
+    if (t === 'resource') return RESOURCE_TIER_ADJECTIVES[item.tier] ?? null
+    if (t === 'component') return COMPONENT_TIER_PREFIXES[item.tier] ?? null
+    if (t === 'module') return MODULE_TIER_PREFIXES[item.tier] ?? null
+    return null
+}
+
+function rootName(item: DisplayNameInput): string {
+    if (itemTypeOf(item) !== 'resource') return item.name
+    return item.category ? CATEGORY_LABELS[item.category] : 'Resource'
+}
+
+// Tier-free display name: includes the resource tier adjective / component-module
+// prefix, but no "(T#)" suffix. Use this when the tier is shown separately.
+export function baseName(item: DisplayNameInput): string {
+    const prefix = tierPrefix(item)
+    const root = rootName(item)
+    return prefix ? `${prefix} ${root}` : root
+}
+
+export function displayName(item: DisplayNameInput): string {
+    return `${baseName(item)} (T${item.tier})`
 }
 
 export interface DescribeOptions {

package/src/resolution/resolve-item.test.ts

@@ -0,0 +1,37 @@
+import {expect, test} from 'bun:test'
+import {UInt16, UInt64} from '@wharfkit/antelope'
+import {resolveItem} from './resolve-item'
+import {encodeStats} from '../derivation/crafting'
+import {computeContainerCapabilities} from '../derivation/capabilities'
+import {
+    ITEM_EXTRACTOR_T1_PACKED,
+    ITEM_FACTORY_T1_PACKED,
+    ITEM_MASS_DRIVER_T1_PACKED,
+    ITEM_MASS_CATCHER_T1_PACKED,
+} from '../data/item-ids'
+
+function hullStats(strength: number, density: number, hardness: number): UInt64 {
+    return UInt64.from(encodeStats([strength, density, hardness]).toString())
+}
+
+const CONTAINER_ENTITIES = [
+    ['factory', ITEM_FACTORY_T1_PACKED],
+    ['extractor', ITEM_EXTRACTOR_T1_PACKED],
+    ['mass driver', ITEM_MASS_DRIVER_T1_PACKED],
+    ['mass catcher', ITEM_MASS_CATCHER_T1_PACKED],
+] as const
+
+for (const [label, itemId] of CONTAINER_ENTITIES) {
+    test(`resolveItem resolves ${label} hull capacity via container formula`, () => {
+        const stats = hullStats(300, 100, 400)
+        const resolved = resolveItem(UInt16.from(itemId), stats)
+        const hull = resolved.attributes?.find((g) => g.capability === 'Hull')
+        const capacity = hull?.attributes.find((a) => a.label === 'Capacity')?.value
+        const expected = computeContainerCapabilities({
+            strength: 300,
+            hardness: 400,
+            density: 100,
+        }).capacity
+        expect(capacity).toBe(expected)
+    })
+}

package/src/resolution/resolve-item.ts

@@ -9,6 +9,7 @@ import {
     isModuleItem,
     MODULE_CRAFTER,
     MODULE_ENGINE,
+    MODULE_BATTERY,
     MODULE_GATHERER,
     MODULE_GENERATOR,
     MODULE_HAULER,
@@ -19,6 +20,7 @@ import {decodeCraftedItemStats, decodeStat} from '../derivation/crafting'
 import {getStatDefinitions} from '../derivation/stats'
 import {
     computeCrafterCapabilities,
+    computeBatteryCapabilities,
     computeEngineCapabilities,
     computeGathererCapabilities,
     computeGeneratorCapabilities,
@@ -26,19 +28,20 @@ import {
     computeLoaderCapabilities,
     computeShipHullCapabilities,
     computeWarehouseHullCapabilities,
-} from '../entities/ship-deploy'
-import {computeContainerCapabilities, computeContainerT2Capabilities} from '../entities/container'
-import {
-    categoryColors,
-    categoryIcons,
-    componentIcon,
-    itemAbbreviations,
-    moduleIcon,
-} from '../data/colors'
+    computeContainerCapabilities,
+    computeContainerT2Capabilities,
+    computeStorageCapabilities,
+} from '../derivation/capabilities'
+import {applySlotMultiplierUint32} from '../entities/slot-multiplier'
+import {categoryColors, componentIcon, itemAbbreviations, moduleIcon} from '../data/colors'
 import type {ServerContract} from '../contracts'
 import {
     ITEM_CONTAINER_T1_PACKED,
     ITEM_CONTAINER_T2_PACKED,
+    ITEM_EXTRACTOR_T1_PACKED,
+    ITEM_FACTORY_T1_PACKED,
+    ITEM_MASS_CATCHER_T1_PACKED,
+    ITEM_MASS_DRIVER_T1_PACKED,
     ITEM_SHIP_T1_PACKED,
     ITEM_WAREHOUSE_T1_PACKED,
 } from '../data/item-ids'
@@ -62,6 +65,7 @@ export type ResolvedItemType = 'resource' | 'component' | 'module' | 'entity'
 
 export interface ResolvedModuleSlot {
     name?: string
+    capability?: string
     installed: boolean
     attributes?: {label: string; value: number}[]
 }
@@ -109,7 +113,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,
@@ -155,7 +159,9 @@ function resolveComponent(id: number, stats?: UInt64Type): ResolvedItem {
 
 function computeCapabilityGroup(
     moduleType: number,
-    stats: Record<string, number>
+    stats: Record<string, number>,
+    tier: number,
+    outputPct = 100
 ): ResolvedAttributeGroup | undefined {
     switch (moduleType) {
         case MODULE_ENGINE: {
@@ -179,14 +185,13 @@ function computeCapabilityGroup(
             }
         }
         case MODULE_GATHERER: {
-            const caps = computeGathererCapabilities(stats)
+            const caps = computeGathererCapabilities(stats, tier)
             return {
                 capability: 'Gatherer',
                 attributes: [
                     {label: 'Yield', value: caps.yield},
                     {label: 'Drain', value: caps.drain},
                     {label: 'Depth', value: caps.depth},
-                    {label: 'Speed', value: caps.speed},
                 ],
             }
         }
@@ -223,13 +228,28 @@ function computeCapabilityGroup(
             }
         }
         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)
+            return {
+                capability: 'Storage',
+                attributes: [
+                    {
+                        label: 'Cargo Capacity',
+                        value: applySlotMultiplierUint32(caps.capacity, outputPct),
+                    },
+                ],
+            }
+        }
+        case MODULE_BATTERY: {
+            const caps = computeBatteryCapabilities(stats)
+            return {
+                capability: 'Energy',
+                attributes: [
+                    {
+                        label: 'Energy Capacity',
+                        value: applySlotMultiplierUint32(caps.capacity, outputPct),
+                    },
+                ],
+            }
         }
         default:
             return undefined
@@ -242,7 +262,7 @@ function resolveModule(id: number, stats?: UInt64Type): ResolvedItem {
     if (stats !== undefined) {
         const decoded = decodeCraftedItemStats(id, toBigStats(stats))
         const modType = getModuleCapabilityType(id)
-        const group = computeCapabilityGroup(modType, decoded)
+        const group = computeCapabilityGroup(modType, decoded, item.tier)
         if (group) attributes = [group]
     }
     return {
@@ -269,6 +289,10 @@ function hullCapsForEntity(
             return computeShipHullCapabilities(decoded)
         case ITEM_WAREHOUSE_T1_PACKED:
             return computeWarehouseHullCapabilities(decoded)
+        case ITEM_EXTRACTOR_T1_PACKED:
+        case ITEM_FACTORY_T1_PACKED:
+        case ITEM_MASS_DRIVER_T1_PACKED:
+        case ITEM_MASS_CATCHER_T1_PACKED:
         case ITEM_CONTAINER_T1_PACKED:
             return computeContainerCapabilities(decoded)
         case ITEM_CONTAINER_T2_PACKED:
@@ -289,7 +313,10 @@ function resolveEntity(
     let moduleSlots: ResolvedModuleSlot[] | undefined
 
     if (stats !== undefined) {
-        const decoded = decodeCraftedItemStats(id, toBigStats(stats))
+        const bigStats = toBigStats(stats)
+        const decoded = decodeCraftedItemStats(id, bigStats)
+        if (decoded.strength === undefined) decoded.strength = decodeStat(bigStats, 0)
+        if (decoded.hardness === undefined) decoded.hardness = decodeStat(bigStats, 2)
         const hullCaps = hullCapsForEntity(id, decoded)
         attributes = [
             {
@@ -311,15 +338,19 @@ function resolveEntity(
                 const modStats = BigInt(mod.installed.stats.toString())
                 const decodedStats = decodeCraftedItemStats(modItemId, modStats)
                 const modType = getModuleCapabilityType(modItemId)
-                const group = computeCapabilityGroup(modType, decodedStats)
                 let modName = 'Module'
+                let modTier = 1
                 try {
-                    modName = getItem(modItemId).name
+                    const modItem = getItem(modItemId)
+                    modName = modItem.name
+                    modTier = modItem.tier
                 } catch {
                     modName = itemMetadata[modItemId]?.name ?? 'Module'
                 }
+                const group = computeCapabilityGroup(modType, decodedStats, modTier, slot.outputPct)
                 return {
                     name: modName,
+                    capability: group?.capability,
                     installed: true,
                     attributes: group?.attributes,
                 }

package/src/scan/index.ts

@@ -0,0 +1,180 @@
+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)))
+
+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[] {
+    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
+}
+
+export async function scanCells(
+    gameSeed: string,
+    epochSeed: string,
+    cells: Coord[]
+): Promise<DerivedCell[]> {
+    await scanReady()
+    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.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 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),
+            ],
+        })
+    }
+    return out
+}