@shipload/sdk 1.0.0-next.71 → 1.0.0-next.73

package/src/data/catalog.test.ts

@@ -1,5 +1,8 @@
 import {describe, expect, test} from 'bun:test'
-import {getItems, itemTypeIndex, typeLabel} from './catalog'
+import {getComponents, getItem, getItems, itemTypeIndex, typeLabel} from './catalog'
+import {getRecipe} from './recipes-runtime'
+import items from './items.json'
+import {itemFamilies, itemFamilyKey} from './metadata'
 
 describe('itemTypeIndex', () => {
     test('agrees with typeLabel for every item in the catalog', () => {
@@ -17,3 +20,80 @@ describe('itemTypeIndex', () => {
         expect(() => itemTypeIndex(65535)).toThrow()
     })
 })
+
+const catalogItems = () => (items as Array<{id: number}>).map((raw) => getItem(raw.id))
+
+describe('item families', () => {
+    test('every item resolves to a family that carries its name', () => {
+        for (const item of catalogItems()) {
+            expect(itemFamilies[item.family]?.name).toBe(item.name)
+        }
+    })
+
+    test('every tier of a family shares one name, description, and colour', () => {
+        const seen = new Map<string, {name: string; description: string; color: string}>()
+        for (const item of catalogItems()) {
+            const prior = seen.get(item.family)
+            if (prior) {
+                expect({
+                    name: item.name,
+                    description: item.description,
+                    color: item.color,
+                }).toEqual(prior)
+            } else {
+                seen.set(item.family, {
+                    name: item.name,
+                    description: item.description,
+                    color: item.color,
+                })
+            }
+        }
+    })
+
+    test('every family is reachable from at least one item id', () => {
+        const reachable = new Set(catalogItems().map((item) => item.family))
+        for (const id of [10202, 10203, 10204, 10207]) reachable.add(itemFamilyKey(id)!)
+        expect([...Object.keys(itemFamilies)].filter((key) => !reachable.has(key))).toEqual([])
+    })
+
+    test('descriptions never name a tier', () => {
+        for (const [key, family] of Object.entries(itemFamilies)) {
+            expect(`${key}: ${family.description}`).not.toMatch(/\btier\b|\bT\d\b/i)
+        }
+    })
+})
+
+describe('component descriptions', () => {
+    test('name only items that a recipe actually builds from the component', () => {
+        const consumers = new Map<string, Set<string>>()
+        for (const output of getItems()) {
+            const recipe = getRecipe(output.id)
+            if (!recipe) continue
+            for (const input of recipe.inputs) {
+                const inputItem = getItem(input.itemId)
+                if (inputItem.type !== 'component') continue
+                if (!consumers.has(inputItem.family)) consumers.set(inputItem.family, new Set())
+                consumers
+                    .get(inputItem.family)!
+                    .add(
+                        output.type === 'entity' && output.family !== 'container'
+                            ? 'hulls'
+                            : output.name
+                    )
+            }
+        }
+        for (const item of getComponents({tier: 1})) {
+            const named = item.description
+                .replace(/^Goes into /, '')
+                .replace(/\.$/, '')
+                .split(/, and |, | and /)
+                .map((name) => name.replace(/s$/, ''))
+            for (const name of named) {
+                const plain = name === 'hull' ? 'hulls' : name
+                expect(consumers.get(item.family)?.has(plain), `${item.name} -> ${plain}`).toBe(
+                    true
+                )
+            }
+        }
+    })
+})

package/src/data/catalog.ts

@@ -1,6 +1,6 @@
 import {UInt16, type UInt16Type} from '@wharfkit/antelope'
 import items from './items.json'
-import {itemMetadata} from './metadata'
+import {getItemFamily, itemFamilyKey} from './metadata'
 import {
     CATEGORY_LABELS,
     type Item,
@@ -12,12 +12,14 @@ import {
 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.`)
+    const family = itemFamilyKey(raw.id)
+    const meta = getItemFamily(raw.id)
+    if (!family || !meta) {
+        throw new Error(`Missing family for item ${raw.id}. Add an entry to metadata.ts.`)
     }
     itemsById.set(raw.id, {
         id: raw.id,
+        family,
         name: meta.name,
         description: meta.description,
         color: meta.color,

package/src/data/entities.json

@@ -35,69 +35,6 @@
     ],
     "baseHullmass": 40000
   },
-  {
-    "entityItemId": 10202,
-    "slots": [
-      {
-        "type": "loader",
-        "outputPct": 100,
-        "maxTier": 1
-      },
-      {
-        "type": "storage",
-        "outputPct": 100,
-        "maxTier": 1
-      },
-      {
-        "type": "storage",
-        "outputPct": 100,
-        "maxTier": 1
-      },
-      {
-        "type": "storage",
-        "outputPct": 100,
-        "maxTier": 1
-      },
-      {
-        "type": "storage",
-        "outputPct": 100,
-        "maxTier": 1
-      }
-    ],
-    "baseHullmass": 1000
-  },
-  {
-    "entityItemId": 10203,
-    "slots": [
-      {
-        "type": "generator",
-        "outputPct": 200,
-        "maxTier": 1
-      },
-      {
-        "type": "gatherer",
-        "outputPct": 200,
-        "maxTier": 1
-      }
-    ],
-    "baseHullmass": 1000
-  },
-  {
-    "entityItemId": 10204,
-    "slots": [
-      {
-        "type": "generator",
-        "outputPct": 200,
-        "maxTier": 1
-      },
-      {
-        "type": "crafter",
-        "outputPct": 200,
-        "maxTier": 1
-      }
-    ],
-    "baseHullmass": 1000
-  },
   {
     "entityItemId": 10205,
     "slots": [
@@ -135,11 +72,6 @@
     ],
     "baseHullmass": 1000
   },
-  {
-    "entityItemId": 10207,
-    "slots": [],
-    "baseHullmass": 1000
-  },
   {
     "entityItemId": 10208,
     "slots": [
@@ -380,6 +312,90 @@
     "slots": [],
     "baseHullmass": 1000
   },
+  {
+    "entityItemId": 11202,
+    "slots": [
+      {
+        "type": "loader",
+        "outputPct": 100,
+        "maxTier": 2
+      },
+      {
+        "type": "storage",
+        "outputPct": 100,
+        "maxTier": 2
+      },
+      {
+        "type": "storage",
+        "outputPct": 100,
+        "maxTier": 2
+      },
+      {
+        "type": "storage",
+        "outputPct": 100,
+        "maxTier": 2
+      },
+      {
+        "type": "storage",
+        "outputPct": 100,
+        "maxTier": 2
+      }
+    ],
+    "baseHullmass": 1000
+  },
+  {
+    "entityItemId": 11203,
+    "slots": [
+      {
+        "type": "generator",
+        "outputPct": 200,
+        "maxTier": 2
+      },
+      {
+        "type": "gatherer",
+        "outputPct": 200,
+        "maxTier": 2
+      }
+    ],
+    "baseHullmass": 1000
+  },
+  {
+    "entityItemId": 11204,
+    "slots": [
+      {
+        "type": "generator",
+        "outputPct": 200,
+        "maxTier": 2
+      },
+      {
+        "type": "crafter",
+        "outputPct": 200,
+        "maxTier": 2
+      }
+    ],
+    "baseHullmass": 1000
+  },
+  {
+    "entityItemId": 11207,
+    "slots": [],
+    "baseHullmass": 1000
+  },
+  {
+    "entityItemId": 11209,
+    "slots": [
+      {
+        "type": "generator",
+        "outputPct": 200,
+        "maxTier": 2
+      },
+      {
+        "type": "builder",
+        "outputPct": 200,
+        "maxTier": 2
+      }
+    ],
+    "baseHullmass": 1000
+  },
   {
     "entityItemId": 11212,
     "slots": [

package/src/data/item-ids.ts

@@ -73,12 +73,8 @@ export const ITEM_LAUNCHER_T1 = 10109
 export const ITEM_BUILDER_T1 = 10110
 export const ITEM_CONTAINER_T1_PACKED = 10200
 export const ITEM_SHIP_T1_PACKED = 10201
-export const ITEM_WAREHOUSE_T1_PACKED = 10202
-export const ITEM_EXTRACTOR_T1_PACKED = 10203
-export const ITEM_FACTORY_T1_PACKED = 10204
 export const ITEM_MASS_DRIVER_T1_PACKED = 10205
 export const ITEM_MASS_CATCHER_T1_PACKED = 10206
-export const ITEM_HUB_T1_PACKED = 10207
 export const ITEM_WORKSHOP_T1_PACKED = 10208
 export const ITEM_CONSTRUCTION_DOCK_T1_PACKED = 10209
 export const ITEM_ROUSTABOUT_T1A_PACKED = 10210
@@ -111,6 +107,11 @@ export const ITEM_WARP_T2 = 11107
 export const ITEM_BATTERY_T2 = 11108
 export const ITEM_BUILDER_T2 = 11110
 export const ITEM_CONTAINER_T2_PACKED = 11200
+export const ITEM_WAREHOUSE_T2_PACKED = 11202
+export const ITEM_EXTRACTOR_T2_PACKED = 11203
+export const ITEM_FACTORY_T2_PACKED = 11204
+export const ITEM_HUB_T2_PACKED = 11207
+export const ITEM_ASSEMBLY_YARD_T2_PACKED = 11209
 export const ITEM_PROSPECTOR_T2A_PACKED = 11212
 export const ITEM_PROSPECTOR_T2B_PACKED = 11213
 export const ITEM_DREDGER_T2A_PACKED = 11214

package/src/data/items.json

@@ -498,24 +498,6 @@
     "type": "entity",
     "tier": 1
   },
-  {
-    "id": 10202,
-    "mass": 32000,
-    "type": "entity",
-    "tier": 1
-  },
-  {
-    "id": 10203,
-    "mass": 19000,
-    "type": "entity",
-    "tier": 1
-  },
-  {
-    "id": 10204,
-    "mass": 19000,
-    "type": "entity",
-    "tier": 1
-  },
   {
     "id": 10205,
     "mass": 80000,
@@ -528,12 +510,6 @@
     "type": "entity",
     "tier": 1
   },
-  {
-    "id": 10207,
-    "mass": 24000,
-    "type": "entity",
-    "tier": 1
-  },
   {
     "id": 10208,
     "mass": 48000,
@@ -736,6 +712,36 @@
     "type": "entity",
     "tier": 2
   },
+  {
+    "id": 11202,
+    "mass": 51200,
+    "type": "entity",
+    "tier": 2
+  },
+  {
+    "id": 11203,
+    "mass": 30400,
+    "type": "entity",
+    "tier": 2
+  },
+  {
+    "id": 11204,
+    "mass": 30400,
+    "type": "entity",
+    "tier": 2
+  },
+  {
+    "id": 11207,
+    "mass": 38400,
+    "type": "entity",
+    "tier": 2
+  },
+  {
+    "id": 11209,
+    "mass": 30400,
+    "type": "entity",
+    "tier": 2
+  },
   {
     "id": 11212,
     "mass": 43200,

package/src/data/kind-registry.json

@@ -84,6 +84,13 @@
       "zCoord": 0,
       "defaultLabel": "Construction Dock"
     },
+    {
+      "kind": "asmblyard",
+      "classification": "OrbitalStructure",
+      "capabilityFlags": 20,
+      "zCoord": 0,
+      "defaultLabel": "Assembly Yard"
+    },
     {
       "kind": "depot",
       "classification": "PlanetaryStructure",
@@ -96,117 +103,146 @@
     {
       "itemId": 10201,
       "kind": "ship",
-      "displayLabel": "Ship"
+      "displayLabel": "Ship",
+      "baseCapacityFn": "ship"
     },
     {
       "itemId": 10210,
       "kind": "ship",
-      "displayLabel": "Roustabout"
+      "displayLabel": "Roustabout",
+      "baseCapacityFn": "ship"
     },
     {
       "itemId": 10211,
       "kind": "ship",
-      "displayLabel": "Prospector"
+      "displayLabel": "Prospector",
+      "baseCapacityFn": "ship"
     },
     {
       "itemId": 10212,
       "kind": "ship",
-      "displayLabel": "Tender"
+      "displayLabel": "Tender",
+      "baseCapacityFn": "ship"
     },
     {
       "itemId": 10213,
       "kind": "ship",
-      "displayLabel": "Wright"
+      "displayLabel": "Wright",
+      "baseCapacityFn": "ship"
     },
     {
       "itemId": 10214,
       "kind": "ship",
-      "displayLabel": "Tug"
+      "displayLabel": "Tug",
+      "baseCapacityFn": "ship"
     },
     {
       "itemId": 10215,
       "kind": "ship",
-      "displayLabel": "Porter"
+      "displayLabel": "Porter",
+      "baseCapacityFn": "ship"
     },
     {
       "itemId": 10218,
       "kind": "ship",
-      "displayLabel": "Smith"
-    },
-    {
-      "itemId": 10202,
-      "kind": "warehouse",
-      "displayLabel": ""
-    },
-    {
-      "itemId": 10203,
-      "kind": "extractor",
-      "displayLabel": ""
-    },
-    {
-      "itemId": 10204,
-      "kind": "factory",
-      "displayLabel": ""
+      "displayLabel": "Smith",
+      "baseCapacityFn": "ship"
     },
     {
       "itemId": 10205,
       "kind": "mdriver",
-      "displayLabel": ""
+      "displayLabel": "",
+      "baseCapacityFn": "container"
     },
     {
       "itemId": 10206,
       "kind": "mcatcher",
-      "displayLabel": ""
+      "displayLabel": "",
+      "baseCapacityFn": "container"
     },
     {
       "itemId": 10200,
       "kind": "container",
-      "displayLabel": ""
+      "displayLabel": "",
+      "baseCapacityFn": "container"
     },
     {
       "itemId": 11200,
       "kind": "container",
-      "displayLabel": ""
-    },
-    {
-      "itemId": 10207,
-      "kind": "hub",
-      "displayLabel": ""
+      "displayLabel": "",
+      "baseCapacityFn": "container"
     },
     {
       "itemId": 10208,
       "kind": "workshop",
-      "displayLabel": ""
+      "displayLabel": "",
+      "baseCapacityFn": "workshop"
     },
     {
       "itemId": 10209,
       "kind": "builddock",
-      "displayLabel": ""
+      "displayLabel": "",
+      "baseCapacityFn": "container"
     },
     {
       "itemId": 10216,
       "kind": "nexus",
-      "displayLabel": ""
+      "displayLabel": "",
+      "baseCapacityFn": "container"
     },
     {
       "itemId": 11212,
       "kind": "ship",
-      "displayLabel": "Prospector"
+      "displayLabel": "Prospector",
+      "baseCapacityFn": "ship"
     },
     {
       "itemId": 11213,
       "kind": "ship",
-      "displayLabel": "Prospector"
+      "displayLabel": "Prospector",
+      "baseCapacityFn": "ship"
     },
     {
       "itemId": 11214,
       "kind": "ship",
-      "displayLabel": "Dredger"
+      "displayLabel": "Dredger",
+      "baseCapacityFn": "ship"
     },
     {
       "itemId": 10219,
       "kind": "depot",
-      "displayLabel": ""
+      "displayLabel": "",
+      "baseCapacityFn": "depot"
+    },
+    {
+      "itemId": 11202,
+      "kind": "warehouse",
+      "displayLabel": "",
+      "baseCapacityFn": "warehouse"
+    },
+    {
+      "itemId": 11203,
+      "kind": "extractor",
+      "displayLabel": "",
+      "baseCapacityFn": "container"
+    },
+    {
+      "itemId": 11204,
+      "kind": "factory",
+      "displayLabel": "",
+      "baseCapacityFn": "container"
+    },
+    {
+      "itemId": 11207,
+      "kind": "hub",
+      "displayLabel": "",
+      "baseCapacityFn": ""
+    },
+    {
+      "itemId": 11209,
+      "kind": "asmblyard",
+      "displayLabel": "Assembly Yard",
+      "baseCapacityFn": "container"
     }
   ]
 }

package/src/data/kind-registry.ts

@@ -36,6 +36,7 @@ export type EntityTypeName =
     | 'mcatcher'
     | 'hub'
     | 'depot'
+    | 'asmblyard'
 
 export interface KindMeta {
     kind: Name
@@ -49,6 +50,7 @@ export interface TemplateMeta {
     itemId: number
     kind: Name
     displayLabel: string
+    baseCapacityFn: string
 }
 
 interface RawKindEntry {
@@ -63,6 +65,7 @@ interface RawTemplateEntry {
     itemId: number
     kind: string
     displayLabel: string
+    baseCapacityFn: string
 }
 
 const KIND_META: Map<string, KindMeta> = (() => {
@@ -96,6 +99,7 @@ const TEMPLATE_BY_ITEM_ID: Map<number, TemplateMeta> = (() => {
             itemId: r.itemId,
             kind: Name.from(r.kind),
             displayLabel: r.displayLabel,
+            baseCapacityFn: r.baseCapacityFn,
         })
     }
     return m
@@ -114,6 +118,11 @@ export function getTemplateMeta(itemId: number): TemplateMeta | undefined {
     return TEMPLATE_BY_ITEM_ID.get(itemId)
 }
 
+export function getBaseCapacityFnName(itemId: number): string | undefined {
+    const fn = TEMPLATE_BY_ITEM_ID.get(itemId)?.baseCapacityFn
+    return fn ? fn : undefined
+}
+
 export function getPackedEntityType(itemId: number): Name | null {
     return TEMPLATE_BY_ITEM_ID.get(itemId)?.kind ?? null
 }
@@ -150,6 +159,7 @@ export const ENTITY_MASS_DRIVER = Name.from('mdriver')
 export const ENTITY_MASS_CATCHER = Name.from('mcatcher')
 export const ENTITY_HUB = Name.from('hub')
 export const ENTITY_DEPOT = Name.from('depot')
+export const ENTITY_ASSEMBLY_YARD = Name.from('asmblyard')
 
 export function isShip(entity: {type?: Name}): boolean {
     return entity.type?.equals(ENTITY_SHIP) ?? false
@@ -190,3 +200,6 @@ export function isHub(entity: {type?: Name}): boolean {
 export function isDepot(entity: {type?: Name}): boolean {
     return entity.type?.equals(ENTITY_DEPOT) ?? false
 }
+export function isAssemblyYard(entity: {type?: Name}): boolean {
+    return entity.type?.equals(ENTITY_ASSEMBLY_YARD) ?? false
+}