@shipload/sdk 2.0.0-rc2 → 2.0.0-rc21

package/src/managers/locations.ts

@@ -1,55 +1,11 @@
-import {Bytes, Checksum256, UInt16Type, UInt64, UInt64Type} from '@wharfkit/antelope'
+import {UInt16Type, UInt64, UInt64Type} from '@wharfkit/antelope'
 import {BaseManager} from './base'
-import {CoordinatesType, coordsToLocationId, Distance, GoodPrice} from '../types'
-import {marketPrice, marketPrices} from '../market/market'
+import {CoordinatesType, coordsToLocationId, Distance} from '../types'
 import {hasSystem} from '../utils/system'
 import {findNearbyPlanets} from '../travel/travel'
-import {Location, toLocation} from '../entities/location'
 import {ServerContract} from '../contracts'
 
 export class LocationsManager extends BaseManager {
-    async getMarketPrice(location: CoordinatesType, goodId: number): Promise<GoodPrice> {
-        const game = await this.getGame()
-        const state = await this.getState()
-        return marketPrice(location, goodId, game.config.seed, state)
-    }
-
-    async getMarketPrices(location: CoordinatesType): Promise<GoodPrice[]> {
-        const game = await this.getGame()
-        const state = await this.getState()
-        return marketPrices(location, game.config.seed, state)
-    }
-
-    async getMarketPricesWithSupply(location: CoordinatesType): Promise<GoodPrice[]> {
-        const [game, state, supplyRows] = await Promise.all([
-            this.getGame(),
-            this.getState(),
-            this.getSupplyRows(location),
-        ])
-
-        const prices = marketPrices(location, game.config.seed, state)
-
-        const supplyMap = new Map<number, number>()
-        for (const row of supplyRows) {
-            if (UInt64.from(row.epoch).equals(state.epoch)) {
-                supplyMap.set(Number(row.good_id), Number(row.supply))
-            }
-        }
-
-        return prices.map((price) => {
-            const actualSupply = supplyMap.get(Number(price.id))
-            if (actualSupply !== undefined) {
-                return GoodPrice.from({
-                    id: price.id,
-                    good: price.good,
-                    price: price.price,
-                    supply: UInt64.from(actualSupply),
-                })
-            }
-            return price
-        })
-    }
-
     async hasSystem(location: CoordinatesType): Promise<boolean> {
         const game = await this.getGame()
         return hasSystem(game.config.seed, location)
@@ -63,45 +19,6 @@ export class LocationsManager extends BaseManager {
         return findNearbyPlanets(game.config.seed, origin, maxDistance)
     }
 
-    async getSupplyRows(location: CoordinatesType) {
-        const hash = Checksum256.hash(Bytes.from(`${location.x}-${location.y}`, 'utf8'))
-        return this.server.table('supply').all({
-            index_position: 'secondary',
-            from: hash,
-            to: hash,
-        })
-    }
-
-    async getLocationWithPrices(coords: CoordinatesType): Promise<Location> {
-        const location = toLocation(coords)
-        const prices = await this.getMarketPrices(location.coordinates)
-        location.setMarketPrices(prices)
-        return location
-    }
-
-    async getLocationWithSupply(coords: CoordinatesType): Promise<Location> {
-        const location = toLocation(coords)
-        const [rows, state] = await Promise.all([
-            this.getSupplyRows(location.coordinates),
-            this.getState(),
-        ])
-        location.setLocationRows(rows, state.epoch)
-        return location
-    }
-
-    async getLocationComplete(coords: CoordinatesType): Promise<Location> {
-        const location = toLocation(coords)
-        const [prices, rows, state] = await Promise.all([
-            this.getMarketPrices(location.coordinates),
-            this.getSupplyRows(location.coordinates),
-            this.getState(),
-        ])
-
-        location.setMarketPrices(prices)
-        location.setLocationRows(rows, state.epoch)
-        return location
-    }
-
     async getLocationEntity(
         id: UInt64Type
     ): Promise<ServerContract.Types.location_row | undefined> {

package/src/market/items.ts

@@ -0,0 +1,41 @@
+import {UInt16, UInt16Type} from '@wharfkit/antelope'
+import items from '../data/items.json'
+import {itemMetadata} from '../data/metadata'
+import {Item} from '../types'
+
+const itemsById = new Map<number, Item>()
+
+for (const raw of items as any[]) {
+    const meta = itemMetadata[raw.id]
+    if (!meta) {
+        throw new Error(`Missing metadata for item ${raw.id}. Add an entry to metadata.ts.`)
+    }
+    itemsById.set(raw.id, {
+        id: raw.id,
+        name: meta.name,
+        description: meta.description,
+        color: meta.color,
+        mass: raw.mass,
+        type: raw.type,
+        tier: raw.tier,
+        category: raw.category,
+        moduleType: raw.type === 'module' ? raw.subtype : undefined,
+    })
+}
+
+export const itemIds = Array.from(itemsById.keys())
+
+export function getItem(itemId: UInt16Type): Item {
+    const id = UInt16.from(itemId).toNumber()
+    const item = itemsById.get(id)
+    if (!item) throw new Error(`Unknown item id: ${id}`)
+    return item
+}
+
+export function getItems(): Item[] {
+    return Array.from(itemsById.values())
+}
+
+export function __registerItemInternal(item: Item): void {
+    itemsById.set(item.id, item)
+}

package/src/nft/description.ts

@@ -0,0 +1,176 @@
+import {
+    getModuleCapabilityType,
+    MODULE_CRAFTER,
+    MODULE_ENGINE,
+    MODULE_GATHERER,
+    MODULE_GENERATOR,
+    MODULE_LOADER,
+    MODULE_STORAGE,
+} from '../capabilities/modules'
+import {
+    ITEM_CONTAINER_T1_PACKED,
+    ITEM_CONTAINER_T2_PACKED,
+    ITEM_CRAFTER_T1,
+    ITEM_ENGINE_T1,
+    ITEM_GATHERER_T1,
+    ITEM_GENERATOR_T1,
+    ITEM_LOADER_T1,
+    ITEM_SHIP_T1_PACKED,
+    ITEM_STORAGE_T1,
+    ITEM_WAREHOUSE_T1_PACKED,
+} from '../data/item-ids'
+import {decodeStat} from '../derivation/crafting'
+
+function idiv(a: number, b: number): number {
+    return Math.floor(a / b)
+}
+
+export function computeBaseHullmass(stats: bigint): number {
+    const density = decodeStat(stats, 1)
+    return 25000 + 75 * density
+}
+
+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(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 = (ref: number): number => 1 + idiv(ref * 3, 1000)
+export const computeGathererYield = (str: number): number => 200 + str
+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 = (fin: number): number => Math.max(200, 2000 - fin * 2)
+export const computeLoaderThrust = (pla: number): number => 1 + idiv(pla, 500)
+export const computeCrafterSpeed = (rea: number): number => 100 + idiv(rea * 4, 5)
+export const computeCrafterDrain = (com: number): number => Math.max(5, 30 - idiv(com, 33))
+
+export function entityDisplayName(itemId: number): string {
+    switch (itemId) {
+        case ITEM_SHIP_T1_PACKED:
+            return 'Ship'
+        case ITEM_WAREHOUSE_T1_PACKED:
+            return 'Warehouse'
+        case ITEM_CONTAINER_T1_PACKED:
+            return 'Container'
+        case ITEM_CONTAINER_T2_PACKED:
+            return 'Container'
+        default:
+            return 'Entity'
+    }
+}
+
+export function moduleDisplayName(itemId: number): string {
+    switch (itemId) {
+        case ITEM_ENGINE_T1:
+            return 'Engine'
+        case ITEM_GENERATOR_T1:
+            return 'Generator'
+        case ITEM_GATHERER_T1:
+            return 'Gatherer'
+        case ITEM_LOADER_T1:
+            return 'Loader'
+        case ITEM_CRAFTER_T1:
+            return 'Crafter'
+        case ITEM_STORAGE_T1:
+            return 'Storage'
+        default:
+            return 'Module'
+    }
+}
+
+export function formatModuleLine(slot: number, itemId: number, stats: bigint): string {
+    let out = `Slot ${slot} - `
+    if (itemId === 0) {
+        out += '(empty)'
+        return out
+    }
+
+    out += moduleDisplayName(itemId)
+    const subtype = getModuleCapabilityType(itemId)
+
+    switch (subtype) {
+        case MODULE_ENGINE: {
+            const vol = decodeStat(stats, 0)
+            const thm = decodeStat(stats, 1)
+            out += `  Thrust ${computeEngineThrust(vol)}  Drain ${computeEngineDrain(thm)}`
+            break
+        }
+        case MODULE_GENERATOR: {
+            const res = decodeStat(stats, 0)
+            const ref = decodeStat(stats, 1)
+            out += `  Capacity ${computeGeneratorCap(res)}  Recharge ${computeGeneratorRech(ref)}`
+            break
+        }
+        case MODULE_GATHERER: {
+            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 fin = decodeStat(stats, 0)
+            const pla = decodeStat(stats, 1)
+            out += `  Mass ${computeLoaderMass(fin)}  Thrust ${computeLoaderThrust(pla)}`
+            break
+        }
+        case MODULE_CRAFTER: {
+            const rea = decodeStat(stats, 0)
+            const com = decodeStat(stats, 1)
+            out += `  Speed ${computeCrafterSpeed(rea)}  Drain ${computeCrafterDrain(com)}`
+            break
+        }
+        case MODULE_STORAGE: {
+            const str = decodeStat(stats, 0)
+            const fin = decodeStat(stats, 2)
+            const sat = decodeStat(stats, 3)
+            const sum = str + fin + sat
+            const pct = 10 + idiv(sum * 10, 2997)
+            out += `  +${pct}% capacity`
+            break
+        }
+    }
+    return out
+}
+
+export function buildEntityDescription(
+    itemId: number,
+    hullStats: bigint,
+    moduleItems: number[],
+    moduleStats: bigint[]
+): string {
+    const hullMass = computeBaseHullmass(hullStats)
+    let baseCapacity = 0
+    if (itemId === ITEM_SHIP_T1_PACKED) {
+        baseCapacity = computeBaseCapacityShip(hullStats)
+    } else if (itemId === ITEM_WAREHOUSE_T1_PACKED) {
+        baseCapacity = computeBaseCapacityWarehouse(hullStats)
+    }
+
+    let out = entityDisplayName(itemId)
+    out += ` - Hull ${hullMass} mass`
+    if (baseCapacity > 0) {
+        out += ` * ${baseCapacity} capacity`
+    }
+    out += '\n\n'
+
+    for (let i = 0; i < moduleItems.length; i++) {
+        out += formatModuleLine(i, moduleItems[i], moduleStats[i] ?? 0n)
+        out += '\n'
+    }
+
+    return out
+}

package/src/nft/deserializers.ts

@@ -0,0 +1,83 @@
+import {getEntityLayout} from '../data/recipes-runtime'
+import {moduleSlotTypeToCode} from '../capabilities/modules'
+import {
+    ITEM_TYPE_COMPONENT,
+    ITEM_TYPE_ENTITY,
+    ITEM_TYPE_MODULE,
+    ITEM_TYPE_RESOURCE,
+    itemTypeCode,
+} from '../data/tiers'
+
+export interface NFTInstalledModule {
+    item_id: number
+    stats: string
+}
+
+export interface NFTModuleSlot {
+    type: number
+    installed?: NFTInstalledModule
+}
+
+export interface NFTCargoItem {
+    item_id: number
+    quantity: number
+    stats: string
+    modules?: NFTModuleSlot[]
+}
+
+export interface NFTCommonBase {
+    quantity: number
+    stats: string
+    origin_x: string
+    origin_y: string
+}
+
+export function readCommonBase(data: Record<string, any>): NFTCommonBase {
+    return {
+        quantity: Number(data.quantity),
+        stats: String(data.stats),
+        origin_x: String(data.origin_x),
+        origin_y: String(data.origin_y),
+    }
+}
+
+export function deserializeScalar(data: Record<string, any>, itemId: number): NFTCargoItem {
+    const base = readCommonBase(data)
+    return {item_id: itemId, quantity: base.quantity, stats: base.stats}
+}
+
+export const deserializeResource = deserializeScalar
+export const deserializeComponent = deserializeScalar
+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 moduleStats: string[] = (data.module_stats ?? []).map((v: any) => String(v))
+    const layout = getEntityLayout(itemId)
+    const slots = layout?.slots ?? []
+
+    const modules: NFTModuleSlot[] = slots.map((slot, i) => ({
+        type: moduleSlotTypeToCode(slot.type),
+        installed:
+            moduleItems[i] && moduleItems[i] !== 0
+                ? {item_id: moduleItems[i], stats: moduleStats[i]}
+                : undefined,
+    }))
+
+    return {item_id: itemId, quantity: base.quantity, stats: base.stats, modules}
+}
+
+export function deserializeAsset(data: Record<string, any>, itemId: number): NFTCargoItem {
+    const type = itemTypeCode(itemId)
+    switch (type) {
+        case ITEM_TYPE_RESOURCE:
+        case ITEM_TYPE_COMPONENT:
+        case ITEM_TYPE_MODULE:
+            return deserializeScalar(data, itemId)
+        case ITEM_TYPE_ENTITY:
+            return deserializeEntity(data, itemId)
+        default:
+            throw new Error(`unknown item type ${type} for item ${itemId}`)
+    }
+}

package/src/nft/index.ts

@@ -0,0 +1,2 @@
+export * from './deserializers'
+export * from './description'

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'],
+    },
+    crafter: {
+        id: 'module.crafter.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
+}

package/src/resolution/display-name.ts

@@ -0,0 +1,43 @@
+import type {ResolvedItem} from './resolve-item'
+import type {ResourceCategory} from '../types'
+import {CATEGORY_LABELS, TIER_ADJECTIVES, tierNumber} from '../types'
+import {formatMass as defaultFormatMass} from '../format'
+
+export interface DisplayNameInput {
+    itemType: 'resource' | 'component' | 'module' | 'entity' | string
+    tier: number | string
+    category?: ResourceCategory
+    name: string
+}
+
+function asTierNumber(tier: number | string): number {
+    return typeof tier === 'number' ? tier : tierNumber(tier)
+}
+
+export function displayName(resolved: DisplayNameInput): string {
+    if (resolved.itemType === 'resource') {
+        const adj = TIER_ADJECTIVES[asTierNumber(resolved.tier)] ?? 'Unknown'
+        const cat = resolved.category ? CATEGORY_LABELS[resolved.category] : 'Resource'
+        return `${adj} ${cat}`
+    }
+    return resolved.name
+}
+
+export interface DescribeOptions {
+    translate?: (key: string) => string
+    formatNumber?: (n: number) => string
+    formatMass?: (kg: number) => string
+}
+
+export function describeItem(resolved: ResolvedItem, opts?: DescribeOptions): string {
+    const massFmt = opts?.formatMass ?? defaultFormatMass
+    const mass = massFmt(resolved.mass)
+    const tier = `T${asTierNumber(resolved.tier)}`
+    if (resolved.itemType === 'resource') {
+        const cat = resolved.category ? CATEGORY_LABELS[resolved.category] : 'Resource'
+        const header = `${tier} ${cat}`
+        const stats = resolved.stats?.map((s) => `${s.label} ${s.value}`).join(', ')
+        return [header, stats, mass].filter(Boolean).join(' · ')
+    }
+    return `${tier} ${resolved.name} · ${mass}`
+}