@shipload/sdk 2.0.0-rc20 → 2.0.0-rc22

package/src/index-module.ts

@@ -1,6 +1,8 @@
 export * from './contracts'
 export * from './errors'
 export * from './types'
+export * from './data/item-ids'
+export * from './data/recipes-runtime'
 
 import {ServerContract} from './contracts'
 
@@ -141,9 +143,16 @@ export {
     createProjectedEntity,
     projectEntity,
     projectEntityAt,
+    projectFromCurrentState,
+    projectFromCurrentStateAt,
     validateSchedule,
 } from './scheduling/projection'
-export type {Projectable, ProjectedEntity, ProjectionOptions} from './scheduling/projection'
+export type {
+    Projectable,
+    ProjectableSnapshot,
+    ProjectedEntity,
+    ProjectionOptions,
+} from './scheduling/projection'
 
 export * from './types/capabilities'
 export * from './types/entity'
@@ -182,51 +191,6 @@ export {
 } from './data/capabilities'
 export type {CapabilityAttribute, StatMapping} from './data/capabilities'
 
-export {
-    components,
-    entityRecipes,
-    moduleRecipes,
-    getComponentById,
-    getEntityRecipe,
-    getEntityRecipeByItemId,
-    getModuleRecipe,
-    getModuleRecipeByItemId,
-    getAllCraftableItems,
-    getComponentsForCategory,
-    getComponentsForStat,
-    ITEM_HULL_PLATES,
-    ITEM_CARGO_LINING,
-    ITEM_CONTAINER_T1_PACKED,
-    ITEM_THRUSTER_CORE,
-    ITEM_POWER_CELL,
-    ITEM_ENGINE_T1,
-    ITEM_GENERATOR_T1,
-    ITEM_SHIP_T1_PACKED,
-    ITEM_WAREHOUSE_T1_PACKED,
-    ITEM_MATTER_CONDUIT,
-    ITEM_SURVEY_PROBE,
-    ITEM_CARGO_ARM,
-    ITEM_TOOL_BIT,
-    ITEM_REACTION_CHAMBER,
-    ITEM_GATHERER_T1,
-    ITEM_LOADER_T1,
-    ITEM_CRAFTER_T1,
-    ITEM_STORAGE_T1,
-    ITEM_HULL_PLATES_T2,
-    ITEM_CARGO_LINING_T2,
-    ITEM_CONTAINER_T2_PACKED,
-    ITEM_FOCUSING_ARRAY,
-} from './data/recipes'
-export type {
-    ComponentDefinition,
-    ComponentStat,
-    RecipeInput,
-    EntityRecipe,
-    ModuleRecipe,
-    ModuleSlot,
-    CraftableItem,
-} from './data/recipes'
-
 export {
     encodeStats,
     encodeGatheredCargoStats,
@@ -239,7 +203,6 @@ export {
     computeEntityStats,
     blendCargoStacks,
     blendCrossGroup,
-    categoryItemMass,
     computeInputMass,
     computeCraftedOutputStats,
 } from './derivation/crafting'
@@ -321,7 +284,6 @@ export {
     computeCrafterDrain,
 } from './nft/description'
 
-export {getEntitySlotLayout} from './data/recipes'
 export {
     ITEM_TYPE_RESOURCE,
     ITEM_TYPE_COMPONENT,

package/src/market/items.ts

@@ -1,93 +1,41 @@
 import {UInt16, UInt16Type} from '@wharfkit/antelope'
+import items from '../data/items.json'
+import {itemMetadata} from '../data/metadata'
 import {Item} from '../types'
-import itemsData from '../data/items.json'
-import {computeInputMass} from '../derivation/crafting'
-import {getComponentById, getEntityRecipeByItemId, getModuleRecipeByItemId} from '../data/recipes'
 
-const itemsById: Map<number, Item> = new Map()
-const synthesizedCache: Map<number, Item> = new Map()
+const itemsById = new Map<number, Item>()
 
-for (const g of itemsData) {
-    const item = Item.from({
-        id: g.id,
-        name: g.name,
-        description: g.description,
-        mass: g.mass,
-        category: g.category,
-        tier: g.tier,
-        color: g.color,
-    })
-    itemsById.set(item.id.toNumber(), item)
-}
-
-export const itemIds = Array.from(itemsById.values(), (i) => i.id)
-
-interface RecipeSource {
-    name: string
-    description: string
-    mass: number
-    color: string
-}
-
-function synthesizeItem(id: number, source: RecipeSource): Item {
-    return Item.from({
-        id,
-        name: source.name,
-        description: source.description,
-        mass: source.mass,
-        category: 'ore',
-        tier: 't1',
-        color: source.color,
+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,
     })
 }
 
-function synthesizeFromRecipes(id: number): Item | undefined {
-    const component = getComponentById(id)
-    if (component) return synthesizeItem(id, component)
-
-    const entityRecipe = getEntityRecipeByItemId(id)
-    if (entityRecipe) {
-        return synthesizeItem(id, {
-            ...entityRecipe,
-            mass: computeInputMass(entityRecipe.id, 'entity'),
-        })
-    }
-
-    const moduleRecipe = getModuleRecipeByItemId(id)
-    if (moduleRecipe) {
-        return synthesizeItem(id, {
-            ...moduleRecipe,
-            mass: computeInputMass(moduleRecipe.id, 'module'),
-        })
-    }
-
-    return undefined
-}
+export const itemIds = Array.from(itemsById.keys())
 
 export function getItem(itemId: UInt16Type): Item {
     const id = UInt16.from(itemId).toNumber()
-    const existing = itemsById.get(id) ?? synthesizedCache.get(id)
-    if (existing) return existing
-
-    const synthesized = synthesizeFromRecipes(id)
-    if (synthesized) {
-        synthesizedCache.set(id, synthesized)
-        return synthesized
-    }
-
-    throw new Error(`Item with id ${id} not found`)
+    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())
 }
 
-/**
- * @internal Test-only: registers an item into the in-memory map. Tests should
- * use `test/item-mock.ts`'s `registerMockItem()` instead of calling this directly.
- */
 export function __registerItemInternal(item: Item): void {
-    const id = item.id.toNumber()
-    itemsById.set(id, item)
-    synthesizedCache.delete(id)
+    itemsById.set(item.id, item)
 }

package/src/nft/description.ts

@@ -1,11 +1,5 @@
 import {
     getModuleCapabilityType,
-    ITEM_CRAFTER_T1,
-    ITEM_ENGINE_T1,
-    ITEM_GATHERER_T1,
-    ITEM_GENERATOR_T1,
-    ITEM_LOADER_T1,
-    ITEM_STORAGE_T1,
     MODULE_CRAFTER,
     MODULE_ENGINE,
     MODULE_GATHERER,
@@ -16,9 +10,15 @@ import {
 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/recipes'
+} from '../data/item-ids'
 import {decodeStat} from '../derivation/crafting'
 
 function idiv(a: number, b: number): number {

package/src/nft/deserializers.ts

@@ -1,4 +1,5 @@
-import {getEntitySlotLayout} from '../data/recipes'
+import {getEntityLayout} from '../data/recipes-runtime'
+import {moduleSlotTypeToCode} from '../capabilities/modules'
 import {
     ITEM_TYPE_COMPONENT,
     ITEM_TYPE_ENTITY,
@@ -53,10 +54,11 @@ export function deserializeEntity(data: Record<string, any>, itemId: number): NF
     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 = getEntitySlotLayout(itemId)
+    const layout = getEntityLayout(itemId)
+    const slots = layout?.slots ?? []
 
-    const modules: NFTModuleSlot[] = layout.map((slot, i) => ({
-        type: slot.type,
+    const modules: NFTModuleSlot[] = slots.map((slot, i) => ({
+        type: moduleSlotTypeToCode(slot.type),
         installed:
             moduleItems[i] && moduleItems[i] !== 0
                 ? {item_id: moduleItems[i], stats: moduleStats[i]}

package/src/resolution/display-name.ts

@@ -1,18 +1,22 @@
 import type {ResolvedItem} from './resolve-item'
-import type {ResourceCategory, ResourceTier} from '../types'
+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: ResourceTier | 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[tierNumber(resolved.tier)] ?? 'Unknown'
+        const adj = TIER_ADJECTIVES[asTierNumber(resolved.tier)] ?? 'Unknown'
         const cat = resolved.category ? CATEGORY_LABELS[resolved.category] : 'Resource'
         return `${adj} ${cat}`
     }
@@ -28,7 +32,7 @@ export interface DescribeOptions {
 export function describeItem(resolved: ResolvedItem, opts?: DescribeOptions): string {
     const massFmt = opts?.formatMass ?? defaultFormatMass
     const mass = massFmt(resolved.mass)
-    const tier = `T${tierNumber(resolved.tier)}`
+    const tier = `T${asTierNumber(resolved.tier)}`
     if (resolved.itemType === 'resource') {
         const cat = resolved.category ? CATEGORY_LABELS[resolved.category] : 'Resource'
         const header = `${tier} ${cat}`

package/src/resolution/resolve-item.ts

@@ -1,8 +1,9 @@
 import {UInt16, UInt64} from '@wharfkit/antelope'
 import type {UInt16Type, UInt64Type} from '@wharfkit/antelope'
-import type {ResourceCategory, ResourceTier} from '../types'
+import type {ResourceCategory} from '../types'
 import {getItem} from '../market/items'
-import {getComponentById, getEntityRecipeByItemId, getModuleRecipeByItemId} from '../data/recipes'
+import {getEntityLayout} from '../data/recipes-runtime'
+import {entityMetadata, itemMetadata} from '../data/metadata'
 import {
     getModuleCapabilityType,
     isModuleItem,
@@ -35,6 +36,12 @@ import {
     moduleIcon,
 } from '../data/colors'
 import {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
@@ -42,7 +49,7 @@ export interface ResolvedItemStat {
     abbreviation: string
     value: number
     color: string
-    category: ResourceCategory
+    category?: ResourceCategory
     inverted?: boolean
 }
 
@@ -65,7 +72,7 @@ export interface ResolvedItem {
     icon: string
     abbreviation: string | null
     category?: ResourceCategory
-    tier: ResourceTier
+    tier: number
     mass: number
     itemType: ResolvedItemType
     stats?: ResolvedItemStat[]
@@ -85,7 +92,7 @@ function resolveResource(id: number, stats?: UInt64Type): ResolvedItem {
     const item = getItem(id)
     const cat = item.category
     let resolvedStats: ResolvedItemStat[] | undefined
-    if (stats !== undefined) {
+    if (stats !== undefined && cat) {
         const bigStats = toBigStats(stats)
         const defs = getStatDefinitions(cat)
         const values = [decodeStat(bigStats, 0), decodeStat(bigStats, 1), decodeStat(bigStats, 2)]
@@ -101,19 +108,19 @@ function resolveResource(id: number, stats?: UInt64Type): ResolvedItem {
     }
     return {
         itemId: id,
-        name: item.displayName,
-        icon: categoryIcons[cat] ?? '⬡',
+        name: item.name,
+        icon: cat ? categoryIcons[cat] : '⬡',
         abbreviation: null,
         category: cat,
         tier: item.tier,
-        mass: Number(item.mass.value.toString()),
+        mass: item.mass,
         itemType: 'resource',
         stats: resolvedStats,
     }
 }
 
 function resolveComponent(id: number, stats?: UInt64Type): ResolvedItem {
-    const comp = getComponentById(id)!
+    const item = getItem(id)
     let resolvedStats: ResolvedItemStat[] | undefined
     if (stats !== undefined) {
         const decoded = decodeCraftedItemStats(id, toBigStats(stats))
@@ -124,26 +131,23 @@ function resolveComponent(id: number, stats?: UInt64Type): ResolvedItem {
                 .concat(getStatDefinitions('regolith'))
                 .concat(getStatDefinitions('biomass'))
             const def = allDefs.find((d) => d.key === key)
-            const statDef = comp.stats.find((s) => s.key === key)
-            const cat = (statDef?.source ?? 'ore') as ResourceCategory
             return {
                 key,
                 label: def?.label ?? key,
                 abbreviation: def?.abbreviation ?? key.slice(0, 3).toUpperCase(),
                 value,
-                color: categoryColors[cat],
-                category: cat,
+                color: '#9BADB8',
                 inverted: def?.inverted,
             }
         })
     }
     return {
         itemId: id,
-        name: comp.name,
+        name: item.name,
         icon: itemAbbreviations[id] ?? componentIcon,
         abbreviation: itemAbbreviations[id] ?? null,
-        tier: 't1' as ResourceTier,
-        mass: comp.mass,
+        tier: item.tier,
+        mass: item.mass,
         itemType: 'component',
         stats: resolvedStats,
     }
@@ -220,9 +224,9 @@ function computeCapabilityGroup(
         }
         case MODULE_STORAGE: {
             const str = stats.strength ?? 500
-            const fin = stats.fineness ?? 500
+            const hrd = stats.hardness ?? 500
             const sat = stats.saturation ?? 500
-            const statSum = str + fin + sat
+            const statSum = str + hrd + sat
             const pct = 10 + Math.floor((statSum * 10) / 2997)
             return {capability: 'Storage', attributes: [{label: 'Capacity Bonus', value: pct}]}
         }
@@ -232,7 +236,7 @@ function computeCapabilityGroup(
 }
 
 function resolveModule(id: number, stats?: UInt64Type): ResolvedItem {
-    const recipe = getModuleRecipeByItemId(id)!
+    const item = getItem(id)
     let attributes: ResolvedAttributeGroup[] | undefined
     if (stats !== undefined) {
         const decoded = decodeCraftedItemStats(id, toBigStats(stats))
@@ -242,59 +246,64 @@ function resolveModule(id: number, stats?: UInt64Type): ResolvedItem {
     }
     return {
         itemId: id,
-        name: recipe.name,
+        name: item.name,
         icon: itemAbbreviations[id] ?? moduleIcon,
         abbreviation: itemAbbreviations[id] ?? null,
-        tier: 't1' as ResourceTier,
-        mass: 0,
+        tier: item.tier,
+        mass: item.mass,
         itemType: 'module',
         attributes,
     }
 }
 
+function hullCapsForEntity(
+    itemId: number,
+    decoded: Record<string, number>
+): {
+    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}`)
+    }
+}
+
 function resolveEntity(
     id: number,
     stats?: UInt64Type,
     modules?: ServerContract.Types.module_entry[]
 ): ResolvedItem {
-    const recipe = getEntityRecipeByItemId(id)!
+    const item = getItem(id)
+    const layout = getEntityLayout(id)
     let attributes: ResolvedAttributeGroup[] | undefined
     let moduleSlots: ResolvedModuleSlot[] | undefined
 
     if (stats !== undefined) {
         const decoded = decodeCraftedItemStats(id, toBigStats(stats))
-        attributes = []
-
-        let hullCaps: {hullmass: number; capacity: number}
-        switch (recipe.id) {
-            case 'ship-t1':
-                hullCaps = computeShipHullCapabilities(decoded)
-                break
-            case 'warehouse-t1':
-                hullCaps = computeWarehouseHullCapabilities(decoded)
-                break
-            case 'container':
-                hullCaps = computeContainerCapabilities(decoded)
-                break
-            case 'container-t2':
-                hullCaps = computeContainerT2Capabilities(decoded)
-                break
-            default:
-                throw new Error(
-                    `resolveItem: no capacity formula wired for entity recipe "${recipe.id}"`
-                )
-        }
-        attributes.push({
-            capability: 'Hull',
-            attributes: [
-                {label: 'Mass', value: hullCaps.hullmass},
-                {label: 'Capacity', value: hullCaps.capacity},
-            ],
-        })
+        const hullCaps = hullCapsForEntity(id, decoded)
+        attributes = [
+            {
+                capability: 'Hull',
+                attributes: [
+                    {label: 'Mass', value: hullCaps.hullmass},
+                    {label: 'Capacity', value: hullCaps.capacity},
+                ],
+            },
+        ]
     }
 
-    if (recipe.moduleSlots) {
-        moduleSlots = recipe.moduleSlots.map((slot, i) => {
+    if (layout && layout.slots.length > 0) {
+        const slotLabels = entityMetadata[id]?.moduleSlotLabels ?? []
+        moduleSlots = layout.slots.map((slot, i) => {
             const mod = modules?.[i]
             if (mod?.installed) {
                 const modItemId = Number(mod.installed.item_id.value.toString())
@@ -302,24 +311,32 @@ function resolveEntity(
                 const decodedStats = decodeCraftedItemStats(modItemId, modStats)
                 const modType = getModuleCapabilityType(modItemId)
                 const group = computeCapabilityGroup(modType, decodedStats)
-                const modRecipe = getModuleRecipeByItemId(modItemId)
+                let modName = 'Module'
+                try {
+                    modName = getItem(modItemId).name
+                } catch {
+                    modName = itemMetadata[modItemId]?.name ?? 'Module'
+                }
                 return {
-                    name: modRecipe?.name ?? 'Module',
+                    name: modName,
                     installed: true,
                     attributes: group?.attributes,
                 }
             }
-            return {installed: false}
+            return {
+                name: slotLabels[i] ?? slot.type,
+                installed: false,
+            }
         })
     }
 
     return {
         itemId: id,
-        name: recipe.name,
+        name: item.name,
         icon: itemAbbreviations[id] ?? componentIcon,
         abbreviation: itemAbbreviations[id] ?? null,
-        tier: 't1' as ResourceTier,
-        mass: 0,
+        tier: item.tier,
+        mass: item.mass,
         itemType: 'entity',
         attributes,
         moduleSlots,
@@ -332,12 +349,10 @@ export function resolveItem(
     modules?: ServerContract.Types.module_entry[]
 ): ResolvedItem {
     const id = toNum(itemId)
+    const item = getItem(id)
 
-    if (isModuleItem(id)) return resolveModule(id, stats)
-
-    if (getComponentById(id)) return resolveComponent(id, stats)
-
-    if (getEntityRecipeByItemId(id)) return resolveEntity(id, stats, modules)
-
+    if (item.type === 'module' || isModuleItem(id)) return resolveModule(id, stats)
+    if (item.type === 'component') return resolveComponent(id, stats)
+    if (item.type === 'entity') return resolveEntity(id, stats, modules)
     return resolveResource(id, stats)
 }