@shipload/sdk 2.0.0-rc12 → 2.0.0-rc14

package/src/managers/actions.ts

@@ -1,4 +1,15 @@
-import {Action, Int64, Name, NameType, UInt16, UInt32, UInt64, UInt64Type} from '@wharfkit/antelope'
+import {
+    Action,
+    Int64,
+    Name,
+    NameType,
+    UInt16,
+    UInt16Type,
+    UInt32,
+    UInt32Type,
+    UInt64,
+    UInt64Type,
+} from '@wharfkit/antelope'
 import {BaseManager} from './base'
 import {CoordinatesType, EntityType, EntityTypeName} from '../types'
 import {ServerContract} from '../contracts'
@@ -71,7 +82,8 @@ export class ActionsManager extends BaseManager {
         sourceId: UInt64Type,
         destType: EntityTypeName,
         destId: UInt64Type,
-        goodId: UInt64Type,
+        itemId: UInt64Type,
+        stats: UInt64Type,
         quantity: UInt64Type
     ): Action {
         return this.server.action('transfer', {
@@ -79,7 +91,8 @@ export class ActionsManager extends BaseManager {
             source_id: UInt64.from(sourceId),
             dest_type: destType,
             dest_id: UInt64.from(destId),
-            item_id: UInt16.from(goodId),
+            item_id: UInt16.from(itemId),
+            stats: UInt64.from(stats),
             quantity: UInt32.from(quantity),
         })
     }
@@ -97,10 +110,21 @@ export class ActionsManager extends BaseManager {
         })
     }
 
-    gather(shipId: UInt64Type, stratum: number, quantity: number): Action {
+    gather(
+        source: EntityRefInput,
+        destination: EntityRefInput,
+        stratum: UInt16Type,
+        quantity: UInt32Type
+    ): Action {
         return this.server.action('gather', {
-            entity_type: EntityType.SHIP,
-            id: UInt64.from(shipId),
+            source: ServerContract.Types.entity_ref.from({
+                entity_type: source.entityType,
+                entity_id: UInt64.from(source.entityId),
+            }),
+            destination: ServerContract.Types.entity_ref.from({
+                entity_type: destination.entityType,
+                entity_id: UInt64.from(destination.entityId),
+            }),
             stratum: UInt16.from(stratum),
             quantity: UInt32.from(quantity),
         })
@@ -152,14 +176,14 @@ export class ActionsManager extends BaseManager {
         entityType: EntityTypeName,
         entityId: UInt64Type,
         packedItemId: number,
-        seed: bigint,
+        stats: bigint,
         entityName: string
     ): Action {
         return this.server.action('deploy', {
             entity_type: entityType,
             id: UInt64.from(entityId),
             packed_item_id: UInt16.from(packedItemId),
-            seed: UInt64.from(seed),
+            stats: UInt64.from(stats),
             entity_name: entityName,
         })
     }
@@ -194,6 +218,22 @@ export class ActionsManager extends BaseManager {
         })
     }
 
+    wrap(
+        owner: NameType,
+        entityType: EntityTypeName,
+        entityId: UInt64Type,
+        cargoId: UInt64Type,
+        quantity: UInt64Type
+    ): Action {
+        return this.server.action('wrap', {
+            owner: Name.from(owner),
+            entity_type: entityType,
+            entity_id: UInt64.from(entityId),
+            cargo_id: UInt64.from(cargoId),
+            quantity: UInt64.from(quantity),
+        })
+    }
+
     joinGame(account: NameType, companyName: string): Action[] {
         return [this.foundCompany(account, companyName), this.join(account)]
     }

package/src/nft/description.ts

@@ -25,27 +25,28 @@ function idiv(a: number, b: number): number {
     return Math.floor(a / b)
 }
 
-export function computeBaseHullmass(seed: bigint): number {
-    const density = decodeStat(seed, 1)
+export function computeBaseHullmass(stats: bigint): number {
+    const density = decodeStat(stats, 1)
     return 25000 + 75 * density
 }
 
-export function computeBaseCapacityShip(seed: bigint): number {
-    const s = decodeStat(seed, 0) + decodeStat(seed, 2) + decodeStat(seed, 3)
+export function computeBaseCapacityShip(stats: bigint): number {
+    const s = decodeStat(stats, 0) + decodeStat(stats, 2) + decodeStat(stats, 3)
     return Math.floor(1_000_000 * Math.pow(10, s / 2997))
 }
 
-export function computeBaseCapacityWarehouse(seed: bigint): number {
-    const s = decodeStat(seed, 0) + decodeStat(seed, 2) + decodeStat(seed, 3)
+export function computeBaseCapacityWarehouse(stats: bigint): number {
+    const s = decodeStat(stats, 0) + decodeStat(stats, 2) + decodeStat(stats, 3)
     return Math.floor(20_000_000 * Math.pow(10, s / 2997))
 }
 
 export const computeEngineThrust = (vol: number): number => 400 + idiv(vol * 3, 4)
 export const computeEngineDrain = (thm: number): number => Math.max(30, 50 - idiv(thm, 70))
 export const computeGeneratorCap = (res: number): number => 300 + idiv(res, 6)
-export const computeGeneratorRech = (clr: number): number => 5 + idiv(clr * 15, 1000)
+export const computeGeneratorRech = (clr: number): number => 1 + idiv(clr * 3, 1000)
 export const computeGathererYield = (str: number): number => 200 + str
-export const computeGathererDrain = (con: number): number => Math.max(10, 50 - idiv(con, 20))
+export const computeGathererDrain = (con: number): number =>
+    Math.max(250, 1250 - idiv(con * 25, 20))
 export const computeGathererDepth = (tol: number): number => 200 + idiv(tol * 3, 2)
 export const computeGathererSpeed = (ref: number): number => 100 + idiv(ref * 4, 5)
 export const computeLoaderMass = (duc: number): number => Math.max(200, 2000 - duc * 2)
@@ -87,7 +88,7 @@ export function moduleDisplayName(itemId: number): string {
     }
 }
 
-export function formatModuleLine(slot: number, itemId: number, seed: bigint): string {
+export function formatModuleLine(slot: number, itemId: number, stats: bigint): string {
     let out = `Slot ${slot} - `
     if (itemId === 0) {
         out += '(empty)'
@@ -99,43 +100,43 @@ export function formatModuleLine(slot: number, itemId: number, seed: bigint): st
 
     switch (subtype) {
         case MODULE_ENGINE: {
-            const vol = decodeStat(seed, 0)
-            const thm = decodeStat(seed, 1)
+            const vol = decodeStat(stats, 0)
+            const thm = decodeStat(stats, 1)
             out += `  Thrust ${computeEngineThrust(vol)}  Drain ${computeEngineDrain(thm)}`
             break
         }
         case MODULE_GENERATOR: {
-            const res = decodeStat(seed, 0)
-            const clr = decodeStat(seed, 1)
+            const res = decodeStat(stats, 0)
+            const clr = decodeStat(stats, 1)
             out += `  Capacity ${computeGeneratorCap(res)}  Recharge ${computeGeneratorRech(clr)}`
             break
         }
         case MODULE_GATHERER: {
-            const str = decodeStat(seed, 0)
-            const tol = decodeStat(seed, 1)
-            const con = decodeStat(seed, 3)
-            const ref = decodeStat(seed, 4)
+            const str = decodeStat(stats, 0)
+            const tol = decodeStat(stats, 1)
+            const con = decodeStat(stats, 3)
+            const ref = decodeStat(stats, 4)
             out += `  Yield ${computeGathererYield(str)}  Depth ${computeGathererDepth(
                 tol
             )}  Speed ${computeGathererSpeed(ref)}  Drain ${computeGathererDrain(con)}`
             break
         }
         case MODULE_LOADER: {
-            const duc = decodeStat(seed, 0)
-            const pla = decodeStat(seed, 1)
+            const duc = decodeStat(stats, 0)
+            const pla = decodeStat(stats, 1)
             out += `  Mass ${computeLoaderMass(duc)}  Thrust ${computeLoaderThrust(pla)}`
             break
         }
         case MODULE_CRAFTER: {
-            const rea = decodeStat(seed, 0)
-            const clr = decodeStat(seed, 1)
+            const rea = decodeStat(stats, 0)
+            const clr = decodeStat(stats, 1)
             out += `  Speed ${computeCrafterSpeed(rea)}  Drain ${computeCrafterDrain(clr)}`
             break
         }
         case MODULE_STORAGE: {
-            const str = decodeStat(seed, 0)
-            const duc = decodeStat(seed, 1)
-            const pur = decodeStat(seed, 2)
+            const str = decodeStat(stats, 0)
+            const duc = decodeStat(stats, 1)
+            const pur = decodeStat(stats, 2)
             const sum = str + duc + pur
             const pct = 10 + idiv(sum * 10, 2997)
             out += `  +${pct}% capacity`
@@ -147,16 +148,16 @@ export function formatModuleLine(slot: number, itemId: number, seed: bigint): st
 
 export function buildEntityDescription(
     itemId: number,
-    hullSeed: bigint,
+    hullStats: bigint,
     moduleItems: number[],
-    moduleSeeds: bigint[]
+    moduleStats: bigint[]
 ): string {
-    const hullMass = computeBaseHullmass(hullSeed)
+    const hullMass = computeBaseHullmass(hullStats)
     let baseCapacity = 0
     if (itemId === ITEM_SHIP_T1_PACKED) {
-        baseCapacity = computeBaseCapacityShip(hullSeed)
+        baseCapacity = computeBaseCapacityShip(hullStats)
     } else if (itemId === ITEM_WAREHOUSE_T1_PACKED) {
-        baseCapacity = computeBaseCapacityWarehouse(hullSeed)
+        baseCapacity = computeBaseCapacityWarehouse(hullStats)
     }
 
     let out = entityDisplayName(itemId)
@@ -167,7 +168,7 @@ export function buildEntityDescription(
     out += '\n\n'
 
     for (let i = 0; i < moduleItems.length; i++) {
-        out += formatModuleLine(i, moduleItems[i], moduleSeeds[i] ?? 0n)
+        out += formatModuleLine(i, moduleItems[i], moduleStats[i] ?? 0n)
         out += '\n'
     }
 

package/src/nft/deserializers.ts

@@ -9,7 +9,7 @@ import {
 
 export interface NFTInstalledModule {
     item_id: number
-    seed: string
+    stats: string
 }
 
 export interface NFTModuleSlot {
@@ -20,13 +20,13 @@ export interface NFTModuleSlot {
 export interface NFTCargoItem {
     item_id: number
     quantity: number
-    seed: string
+    stats: string
     modules?: NFTModuleSlot[]
 }
 
 export interface NFTCommonBase {
     quantity: number
-    seed: string
+    stats: string
     origin_x: string
     origin_y: string
 }
@@ -34,7 +34,7 @@ export interface NFTCommonBase {
 export function readCommonBase(data: Record<string, any>): NFTCommonBase {
     return {
         quantity: Number(data.quantity),
-        seed: String(data.seed),
+        stats: String(data.stats),
         origin_x: String(data.origin_x),
         origin_y: String(data.origin_y),
     }
@@ -42,7 +42,7 @@ export function readCommonBase(data: Record<string, any>): NFTCommonBase {
 
 export function deserializeScalar(data: Record<string, any>, itemId: number): NFTCargoItem {
     const base = readCommonBase(data)
-    return {item_id: itemId, quantity: base.quantity, seed: base.seed}
+    return {item_id: itemId, quantity: base.quantity, stats: base.stats}
 }
 
 export const deserializeResource = deserializeScalar
@@ -52,18 +52,18 @@ export const deserializeModule = deserializeScalar
 export function deserializeEntity(data: Record<string, any>, itemId: number): NFTCargoItem {
     const base = readCommonBase(data)
     const moduleItems: number[] = (data.module_items ?? []).map((v: any) => Number(v))
-    const moduleSeeds: string[] = (data.module_seeds ?? []).map((v: any) => String(v))
+    const moduleStats: string[] = (data.module_stats ?? []).map((v: any) => String(v))
     const layout = getEntitySlotLayout(itemId)
 
     const modules: NFTModuleSlot[] = layout.map((slot, i) => ({
         type: slot.type,
         installed:
             moduleItems[i] && moduleItems[i] !== 0
-                ? {item_id: moduleItems[i], seed: moduleSeeds[i]}
+                ? {item_id: moduleItems[i], stats: moduleStats[i]}
                 : undefined,
     }))
 
-    return {item_id: itemId, quantity: base.quantity, seed: base.seed, modules}
+    return {item_id: itemId, quantity: base.quantity, stats: base.stats, modules}
 }
 
 export function deserializeAsset(data: Record<string, any>, itemId: number): NFTCargoItem {

package/src/resolution/describe-module.ts

@@ -0,0 +1,165 @@
+import type {ResolvedItem, ResolvedModuleSlot} from './resolve-item'
+
+export interface TextSpan {
+    text: string
+    highlight?: boolean
+}
+
+export interface CapabilityInput {
+    capability: string
+    attributes: {label: string; value: number}[]
+}
+
+export interface ModuleDescription {
+    id: string
+    template: string
+    params: Readonly<Record<string, number | string>>
+    highlightKeys: readonly string[]
+}
+
+export interface RenderDescriptionOptions {
+    translate?: (id: string, fallback: string) => string
+    formatNumber?: (n: number) => string
+}
+
+interface TemplateSpec {
+    id: string
+    template: string
+    params: readonly [string, string][]
+    highlightKeys: readonly string[]
+}
+
+const TEMPLATES: Record<string, TemplateSpec> = {
+    engine: {
+        id: 'module.engine.description',
+        template:
+            'generates {thrust} thrust for travel while draining {drain} energy per distance travelled',
+        params: [
+            ['thrust', 'Thrust'],
+            ['drain', 'Drain'],
+        ],
+        highlightKeys: ['thrust', 'drain'],
+    },
+    generator: {
+        id: 'module.generator.description',
+        template:
+            'holds {capacity} maximum energy and restores {recharge} per second while recharging',
+        params: [
+            ['capacity', 'Capacity'],
+            ['recharge', 'Recharge'],
+        ],
+        highlightKeys: ['capacity', 'recharge'],
+    },
+    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',
+        params: [
+            ['yield', 'Yield'],
+            ['drain', 'Drain'],
+            ['depth', 'Depth'],
+            ['speed', 'Speed'],
+        ],
+        highlightKeys: ['yield', 'depth', 'speed', 'drain'],
+    },
+    loader: {
+        id: 'module.loader.description',
+        template:
+            '{quantity} loader that generates {thrust} thrust with a weight of {mass} per unit',
+        params: [
+            ['quantity', 'Quantity'],
+            ['thrust', 'Thrust'],
+            ['mass', 'Mass'],
+        ],
+        highlightKeys: ['quantity', 'thrust', 'mass'],
+    },
+    manufacturing: {
+        id: 'module.manufacturing.description',
+        template: 'manufactures items at {speed} speed while draining {drain} energy per second',
+        params: [
+            ['speed', 'Speed'],
+            ['drain', 'Drain'],
+        ],
+        highlightKeys: ['speed', 'drain'],
+    },
+    storage: {
+        id: 'module.storage.description',
+        template: 'boosts cargo capacity by {bonus}%',
+        params: [['bonus', 'Capacity Bonus']],
+        highlightKeys: ['bonus'],
+    },
+    hauler: {
+        id: 'module.hauler.description',
+        template:
+            'locks onto up to {capacity} targets at {efficiency} efficiency while draining {drain} energy per distance travelled per target',
+        params: [
+            ['capacity', 'Capacity'],
+            ['efficiency', 'Efficiency'],
+            ['drain', 'Drain'],
+        ],
+        highlightKeys: ['capacity', 'efficiency', 'drain'],
+    },
+}
+
+export function describeModule(input: CapabilityInput): ModuleDescription | null {
+    if (!input.attributes || input.attributes.length === 0) return null
+    const key = input.capability.toLowerCase()
+    const spec = TEMPLATES[key]
+    if (!spec) return null
+    const params: Record<string, number | string> = {}
+    for (const [paramName, attrLabel] of spec.params) {
+        const attr = input.attributes.find((a) => a.label === attrLabel)
+        if (attr) params[paramName] = attr.value
+    }
+    return {
+        id: spec.id,
+        template: spec.template,
+        params,
+        highlightKeys: spec.highlightKeys,
+    }
+}
+
+export function describeModuleForItem(resolved: ResolvedItem): ModuleDescription | null {
+    if (resolved.itemType !== 'module') return null
+    const group = resolved.attributes?.[0]
+    if (!group) return null
+    return describeModule({capability: group.capability, attributes: group.attributes})
+}
+
+export function describeModuleForSlot(slot: ResolvedModuleSlot): ModuleDescription | null {
+    if (!slot.installed || !slot.name || !slot.attributes) return null
+    return describeModule({capability: slot.name, attributes: slot.attributes})
+}
+
+export function renderDescription(
+    desc: ModuleDescription,
+    options?: RenderDescriptionOptions
+): TextSpan[] {
+    const translate = options?.translate ?? ((_id: string, fallback: string) => fallback)
+    const formatNumber = options?.formatNumber ?? ((n: number) => n.toLocaleString('en-US'))
+    const tpl = translate(desc.id, desc.template)
+
+    const spans: TextSpan[] = []
+    const regex = /\{([A-Za-z_][A-Za-z0-9_]*)\}/g
+    let lastIndex = 0
+    let m: RegExpExecArray | null
+    while ((m = regex.exec(tpl)) !== null) {
+        if (m.index > lastIndex) {
+            spans.push({text: tpl.slice(lastIndex, m.index)})
+        }
+        const paramName = m[1] ?? ''
+        const raw = desc.params[paramName]
+        if (raw === undefined) {
+            spans.push({text: `{${paramName}}`})
+        } else {
+            const formatted = typeof raw === 'number' ? formatNumber(raw) : raw
+            const highlight = (desc.highlightKeys as readonly string[]).includes(paramName)
+            spans.push(highlight ? {text: formatted, highlight: true} : {text: formatted})
+        }
+        lastIndex = m.index + m[0].length
+    }
+    if (lastIndex < tpl.length) {
+        spans.push({text: tpl.slice(lastIndex)})
+    }
+    return spans
+}