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

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@shipload/sdk",
     "description": "SDKs for Shipload",
-    "version": "1.0.0-next.3",
+    "version": "1.0.0-next.4",
     "homepage": "https://github.com/shipload/toolkit/tree/master/packages/sdk",
     "repository": {
         "type": "git",

package/src/data/capabilities.ts

@@ -8,7 +8,6 @@ export interface StatMapping {
     stat: string
     capability: string
     attribute: string
-    rationale: string
 }
 
 export const capabilityNames: string[] = [
@@ -27,6 +26,11 @@ export const capabilityNames: string[] = [
 export const capabilityAttributes: CapabilityAttribute[] = [
     {capability: 'Hull', attribute: 'mass', description: 'Total mass of the hull'},
     {capability: 'Storage', attribute: 'capacity', description: 'Maximum mass that can be stored'},
+    {
+        capability: 'Storage',
+        attribute: 'bonus',
+        description: 'Capacity bonus added by an installed Storage module',
+    },
     {capability: 'Movement', attribute: 'thrust', description: 'Propulsion force'},
     {capability: 'Movement', attribute: 'drain', description: 'Energy consumed per movement'},
     {capability: 'Energy', attribute: 'capacity', description: 'Maximum energy storage'},
@@ -65,323 +69,6 @@ export const capabilityAttributes: CapabilityAttribute[] = [
     },
 ]
 
-export const statMappings: StatMapping[] = [
-    {
-        stat: 'Strength',
-        capability: 'Gathering',
-        attribute: 'yield',
-        rationale: 'Raw mechanical force drives faster gathering',
-    },
-    {
-        stat: 'Strength',
-        capability: 'Storage',
-        attribute: 'capacity',
-        rationale: 'Stronger walls hold more capacity per mass',
-    },
-    {
-        stat: 'Strength',
-        capability: 'Launch',
-        attribute: 'capacity',
-        rationale: 'Stronger housing handles larger launch loads',
-    },
-    {
-        stat: 'Tolerance',
-        capability: 'Movement',
-        attribute: 'thrust',
-        rationale: 'Engine components that tolerate more can push harder',
-    },
-    {
-        stat: 'Tolerance',
-        capability: 'Energy',
-        attribute: 'recharge',
-        rationale: 'Generator housing withstands stress for faster recharge',
-    },
-    {
-        stat: 'Tolerance',
-        capability: 'Gathering',
-        attribute: 'depth',
-        rationale: 'Housing withstands pressure/heat at extreme depths',
-    },
-    {
-        stat: 'Tolerance',
-        capability: 'Warp',
-        attribute: 'range',
-        rationale: 'Warp drive housing withstands extreme forces',
-    },
-    {
-        stat: 'Density',
-        capability: 'Hull',
-        attribute: 'mass',
-        rationale: 'Lighter metal = lighter hull',
-    },
-    {
-        stat: 'Density',
-        capability: 'Loader',
-        attribute: 'mass',
-        rationale: 'Lighter metal = lighter loader units',
-    },
-    {
-        stat: 'Density',
-        capability: 'Movement',
-        attribute: 'drain',
-        rationale: 'Lighter components require less energy to move',
-    },
-    {
-        stat: 'Conductivity',
-        capability: 'Movement',
-        attribute: 'drain',
-        rationale: 'Efficient energy transfer reduces movement energy cost',
-    },
-    {
-        stat: 'Conductivity',
-        capability: 'Gathering',
-        attribute: 'drain',
-        rationale: 'Efficient energy transfer reduces gathering energy cost',
-    },
-    {
-        stat: 'Conductivity',
-        capability: 'Crafter',
-        attribute: 'drain',
-        rationale: 'Efficient energy transfer reduces crafting energy cost',
-    },
-    {
-        stat: 'Conductivity',
-        capability: 'Energy',
-        attribute: 'recharge',
-        rationale: 'Better conductivity speeds energy flow during recharge',
-    },
-    {
-        stat: 'Ductility',
-        capability: 'Crafter',
-        attribute: 'quality',
-        rationale: 'Precise shaping enables tighter crafting tolerances',
-    },
-    {
-        stat: 'Ductility',
-        capability: 'Gathering',
-        attribute: 'yield',
-        rationale: 'Precisely shaped conduit components gather faster',
-    },
-    {
-        stat: 'Ductility',
-        capability: 'Storage',
-        attribute: 'capacity',
-        rationale: 'Precision-formed container walls maximize volume',
-    },
-    {
-        stat: 'Ductility',
-        capability: 'Loader',
-        attribute: 'mass',
-        rationale: 'Precision-formed precious metal reduces loader unit mass',
-    },
-    {
-        stat: 'Reflectivity',
-        capability: 'Gathering',
-        attribute: 'depth',
-        rationale: 'Reflective heat shielding protects equipment at depth',
-    },
-    {
-        stat: 'Reflectivity',
-        capability: 'Launch',
-        attribute: 'range',
-        rationale: 'Reflective surfaces focus electromagnetic launch energy',
-    },
-    {
-        stat: 'Volatility',
-        capability: 'Gathering',
-        attribute: 'yield',
-        rationale: 'Energy release powers faster gathering',
-    },
-    {
-        stat: 'Volatility',
-        capability: 'Movement',
-        attribute: 'thrust',
-        rationale: 'Energy release drives propulsion force',
-    },
-    {
-        stat: 'Volatility',
-        capability: 'Loader',
-        attribute: 'thrust',
-        rationale: 'Energy release powers loader motors',
-    },
-    {
-        stat: 'Volatility',
-        capability: 'Launch',
-        attribute: 'capacity',
-        rationale: 'Energy release enables launching heavier payloads',
-    },
-    {
-        stat: 'Reactivity',
-        capability: 'Crafter',
-        attribute: 'speed',
-        rationale: 'Reactive gases accelerate chemical/thermal processing',
-    },
-    {
-        stat: 'Reactivity',
-        capability: 'Gathering',
-        attribute: 'speed',
-        rationale: 'Reactive gases manage heat/friction during gathering',
-    },
-    {
-        stat: 'Reactivity',
-        capability: 'Launch',
-        attribute: 'drain',
-        rationale: 'Reactive gas medium reduces electromagnetic resistance',
-    },
-    {
-        stat: 'Thermal',
-        capability: 'Crafter',
-        attribute: 'quality',
-        rationale: 'Precise thermal control during fabrication',
-    },
-    {
-        stat: 'Thermal',
-        capability: 'Gathering',
-        attribute: 'drain',
-        rationale: 'Thermal management reduces energy waste during gathering',
-    },
-    {
-        stat: 'Thermal',
-        capability: 'Energy',
-        attribute: 'capacity',
-        rationale: 'Thermal management enables denser energy storage',
-    },
-    {
-        stat: 'Resonance',
-        capability: 'Energy',
-        attribute: 'capacity',
-        rationale: 'Resonating crystals store energy in fields',
-    },
-    {
-        stat: 'Resonance',
-        capability: 'Warp',
-        attribute: 'range',
-        rationale: 'Resonant crystals amplify warp field projection',
-    },
-    {
-        stat: 'Resonance',
-        capability: 'Launch',
-        attribute: 'range',
-        rationale: 'Resonant crystals focus electromagnetic launch field',
-    },
-    {
-        stat: 'Resonance',
-        capability: 'Launch',
-        attribute: 'capacity',
-        rationale: 'Stronger resonant field launches heavier payloads',
-    },
-    {
-        stat: 'Hardness',
-        capability: 'Crafter',
-        attribute: 'speed',
-        rationale: 'Hard tooling surfaces cut and shape materials faster',
-    },
-    {
-        stat: 'Hardness',
-        capability: 'Launch',
-        attribute: 'drain',
-        rationale: 'Hard rail surfaces reduce friction, less energy wasted',
-    },
-    {
-        stat: 'Clarity',
-        capability: 'Energy',
-        attribute: 'recharge',
-        rationale: 'Flawless crystals enable smoother energy flow during recharge',
-    },
-    {
-        stat: 'Clarity',
-        capability: 'Crafter',
-        attribute: 'quality',
-        rationale: 'Precision optics for calibration during fabrication',
-    },
-    {
-        stat: 'Clarity',
-        capability: 'Crafter',
-        attribute: 'drain',
-        rationale: 'Precision computing optimizes energy routing in factory',
-    },
-    {
-        stat: 'Plasticity',
-        capability: 'Crafter',
-        attribute: 'speed',
-        rationale: 'Easily reshaped materials speed up processing',
-    },
-    {
-        stat: 'Plasticity',
-        capability: 'Movement',
-        attribute: 'thrust',
-        rationale: 'Flexible polymer seals reduce friction in propulsion',
-    },
-    {
-        stat: 'Plasticity',
-        capability: 'Loader',
-        attribute: 'thrust',
-        rationale: 'Flexible joints improve loader force transfer',
-    },
-    {
-        stat: 'Insulation',
-        capability: 'Movement',
-        attribute: 'drain',
-        rationale: 'Better insulation reduces energy loss during movement',
-    },
-    {
-        stat: 'Insulation',
-        capability: 'Gathering',
-        attribute: 'drain',
-        rationale: 'Better insulation reduces energy loss during gathering',
-    },
-    {
-        stat: 'Insulation',
-        capability: 'Crafter',
-        attribute: 'drain',
-        rationale: 'Better insulation reduces energy loss during crafting',
-    },
-    {
-        stat: 'Insulation',
-        capability: 'Launch',
-        attribute: 'drain',
-        rationale: 'Better insulation reduces energy loss during launch',
-    },
-    {
-        stat: 'Purity',
-        capability: 'Storage',
-        attribute: 'capacity',
-        rationale: 'Purer composites make better containers',
-    },
-    {
-        stat: 'Purity',
-        capability: 'Gathering',
-        attribute: 'speed',
-        rationale: 'Purer bio-lubricants reduce friction during gathering',
-    },
-    {
-        stat: 'Purity',
-        capability: 'Energy',
-        attribute: 'capacity',
-        rationale: 'Purer organic electrolytes store more charge',
-    },
-    {
-        stat: 'Resonance',
-        capability: 'Hauler',
-        attribute: 'capacity',
-        rationale:
-            'Resonant field strength determines how many targets the haul beam can lock onto simultaneously.',
-    },
-    {
-        stat: 'Conductivity',
-        capability: 'Hauler',
-        attribute: 'efficiency',
-        rationale: 'Energy-transfer efficiency reduces the thrust penalty from each hauled target.',
-    },
-    {
-        stat: 'Clarity',
-        capability: 'Hauler',
-        attribute: 'drain',
-        rationale:
-            'Clarity-focused energy routing reduces per-target drain during haul-beam operation.',
-    },
-]
-
 const invertedAttributes = new Set(['drain', 'mass'])
 
 export function isInvertedAttribute(attribute: string): boolean {
@@ -394,15 +81,3 @@ export function getCapabilityAttributes(capability?: string): CapabilityAttribut
     }
     return capabilityAttributes
 }
-
-export function getStatMappings(): StatMapping[] {
-    return statMappings
-}
-
-export function getStatMappingsForStat(stat: string): StatMapping[] {
-    return statMappings.filter((m) => m.stat === stat)
-}
-
-export function getStatMappingsForCapability(capability: string): StatMapping[] {
-    return statMappings.filter((m) => m.capability === capability)
-}

package/src/data/capability-formulas.ts

@@ -0,0 +1,68 @@
+export interface SlotConsumer {
+    capability: string
+    attribute: string
+}
+
+export type SlotConsumerKind =
+    | 'engine'
+    | 'generator'
+    | 'gatherer'
+    | 'loader'
+    | 'crafter'
+    | 'storage'
+    | 'hauler'
+    | 'warp'
+    | 'ship-t1'
+    | 'container-t1'
+    | 'warehouse-t1'
+    | 'container-t2'
+
+const ENTITY_HULL_SLOTS: Record<number, SlotConsumer> = {
+    0: {capability: 'Storage', attribute: 'capacity'},
+    1: {capability: 'Hull', attribute: 'mass'},
+    2: {capability: 'Storage', attribute: 'capacity'},
+    3: {capability: 'Storage', attribute: 'capacity'},
+}
+
+export const SLOT_FORMULAS: Record<SlotConsumerKind, Record<number, SlotConsumer>> = {
+    engine: {
+        0: {capability: 'Movement', attribute: 'thrust'},
+        1: {capability: 'Movement', attribute: 'drain'},
+    },
+    generator: {
+        0: {capability: 'Energy', attribute: 'capacity'},
+        1: {capability: 'Energy', attribute: 'recharge'},
+    },
+    gatherer: {
+        0: {capability: 'Gathering', attribute: 'yield'},
+        1: {capability: 'Gathering', attribute: 'depth'},
+        3: {capability: 'Gathering', attribute: 'drain'},
+        4: {capability: 'Gathering', attribute: 'speed'},
+    },
+    loader: {
+        0: {capability: 'Loader', attribute: 'mass'},
+        1: {capability: 'Loader', attribute: 'thrust'},
+    },
+    crafter: {
+        0: {capability: 'Crafter', attribute: 'speed'},
+        1: {capability: 'Crafter', attribute: 'drain'},
+    },
+    storage: {
+        0: {capability: 'Storage', attribute: 'bonus'},
+        1: {capability: 'Storage', attribute: 'bonus'},
+        2: {capability: 'Storage', attribute: 'bonus'},
+        3: {capability: 'Storage', attribute: 'bonus'},
+    },
+    hauler: {
+        0: {capability: 'Hauler', attribute: 'capacity'},
+        1: {capability: 'Hauler', attribute: 'efficiency'},
+        2: {capability: 'Hauler', attribute: 'drain'},
+    },
+    warp: {
+        0: {capability: 'Warp', attribute: 'range'},
+    },
+    'ship-t1': ENTITY_HULL_SLOTS,
+    'container-t1': ENTITY_HULL_SLOTS,
+    'warehouse-t1': ENTITY_HULL_SLOTS,
+    'container-t2': ENTITY_HULL_SLOTS,
+}

package/src/data/recipes.json

@@ -393,12 +393,7 @@
         ]
       },
       {
-        "sources": [
-          {
-            "inputIndex": 1,
-            "statIndex": 1
-          }
-        ]
+        "sources": []
       },
       {
         "sources": [
@@ -436,8 +431,8 @@
       {
         "sources": [
           {
-            "inputIndex": 0,
-            "statIndex": 0
+            "inputIndex": 1,
+            "statIndex": 1
           }
         ]
       },
@@ -552,7 +547,7 @@
         "sources": [
           {
             "inputIndex": 0,
-            "statIndex": 0
+            "statIndex": 1
           }
         ]
       },
@@ -568,17 +563,12 @@
         "sources": [
           {
             "inputIndex": 0,
-            "statIndex": 1
+            "statIndex": 0
           }
         ]
       },
       {
-        "sources": [
-          {
-            "inputIndex": 1,
-            "statIndex": 1
-          }
-        ]
+        "sources": []
       }
     ],
     "blendWeights": []

package/src/derivation/capability-mappings.ts

@@ -0,0 +1,120 @@
+import {SLOT_FORMULAS, type SlotConsumerKind} from '../data/capability-formulas'
+import {getStatDefinitions, type StatDefinition} from './stats'
+import {
+    getRecipe,
+    type Recipe,
+    type RecipeInput,
+    type RecipeInputCategory,
+} from '../data/recipes-runtime'
+import {
+    ITEM_ENGINE_T1,
+    ITEM_GENERATOR_T1,
+    ITEM_GATHERER_T1,
+    ITEM_LOADER_T1,
+    ITEM_CRAFTER_T1,
+    ITEM_STORAGE_T1,
+    ITEM_HAULER_T1,
+    ITEM_WARP_T1,
+    ITEM_SHIP_T1_PACKED,
+    ITEM_CONTAINER_T1_PACKED,
+    ITEM_WAREHOUSE_T1_PACKED,
+    ITEM_CONTAINER_T2_PACKED,
+} from '../data/item-ids'
+import type {StatMapping} from '../data/capabilities'
+
+export const KIND_TO_ITEM_ID: Record<SlotConsumerKind, number> = {
+    engine: ITEM_ENGINE_T1,
+    generator: ITEM_GENERATOR_T1,
+    gatherer: ITEM_GATHERER_T1,
+    loader: ITEM_LOADER_T1,
+    crafter: ITEM_CRAFTER_T1,
+    storage: ITEM_STORAGE_T1,
+    hauler: ITEM_HAULER_T1,
+    warp: ITEM_WARP_T1,
+    'ship-t1': ITEM_SHIP_T1_PACKED,
+    'container-t1': ITEM_CONTAINER_T1_PACKED,
+    'warehouse-t1': ITEM_WAREHOUSE_T1_PACKED,
+    'container-t2': ITEM_CONTAINER_T2_PACKED,
+}
+
+function isCategoryInput(input: RecipeInput): input is RecipeInputCategory {
+    return 'category' in input
+}
+
+/**
+ * Walk a recipe's slot source down to the raw category stat that ultimately
+ * lands in that slot. Returns the StatDefinition or undefined if the trace
+ * dead-ends (unknown sub-component, missing slot, etc.).
+ *
+ * Multi-source sub-slots collapse to `sources[0]`; top-level multi-source slots
+ * are expanded by the caller (`deriveStatMappings`).
+ */
+function traceToRawCategoryStat(
+    recipe: Recipe,
+    source: {inputIndex: number; statIndex: number},
+    visited: Set<number> = new Set()
+): StatDefinition | undefined {
+    const input = recipe.inputs[source.inputIndex]
+    if (!input) return undefined
+    if (isCategoryInput(input)) {
+        const defs = getStatDefinitions(input.category)
+        return defs[source.statIndex]
+    }
+    if (visited.has(input.itemId)) return undefined
+    const subRecipe = getRecipe(input.itemId)
+    if (!subRecipe) return undefined
+    const subSlot = subRecipe.statSlots[source.statIndex]
+    if (!subSlot) return undefined
+    const subSource = subSlot.sources[0]
+    if (!subSource) return undefined
+    const nextVisited = new Set(visited)
+    nextVisited.add(input.itemId)
+    return traceToRawCategoryStat(subRecipe, subSource, nextVisited)
+}
+
+let cached: StatMapping[] | undefined
+
+export function deriveStatMappings(): StatMapping[] {
+    if (cached) return cached
+    const out: StatMapping[] = []
+    const seen = new Set<string>()
+    for (const [kind, slots] of Object.entries(SLOT_FORMULAS) as [
+        SlotConsumerKind,
+        Record<number, {capability: string; attribute: string}>,
+    ][]) {
+        const itemId = KIND_TO_ITEM_ID[kind]
+        const recipe = getRecipe(itemId)
+        if (!recipe) continue
+        for (const [slotIdxStr, consumer] of Object.entries(slots)) {
+            const slotIdx = Number(slotIdxStr)
+            const slot = recipe.statSlots[slotIdx]
+            if (!slot) continue
+            for (const source of slot.sources) {
+                const stat = traceToRawCategoryStat(recipe, source)
+                if (!stat) continue
+                const key = `${stat.label}|${consumer.capability}|${consumer.attribute}`
+                if (seen.has(key)) continue
+                seen.add(key)
+                out.push({
+                    stat: stat.label,
+                    capability: consumer.capability,
+                    attribute: consumer.attribute,
+                })
+            }
+        }
+    }
+    cached = out
+    return out
+}
+
+export function getStatMappings(): StatMapping[] {
+    return deriveStatMappings()
+}
+
+export function getStatMappingsForStat(stat: string): StatMapping[] {
+    return deriveStatMappings().filter((m) => m.stat === stat)
+}
+
+export function getStatMappingsForCapability(capability: string): StatMapping[] {
+    return deriveStatMappings().filter((m) => m.capability === capability)
+}

package/src/entities/container.ts

@@ -75,10 +75,10 @@ export function computeContainerCapabilities(stats: Record<string, number>): {
     hullmass: number
     capacity: number
 } {
-    const density = stats['density'] ?? 500
-    const strength = stats['strength'] ?? 500
-    const hardness = stats['hardness'] ?? 500
-    const saturation = stats['saturation'] ?? 500
+    const density = stats.density
+    const strength = stats.strength
+    const hardness = stats.hardness
+    const saturation = stats.saturation
 
     const hullmass = 25000 + 75 * density
 
@@ -93,10 +93,10 @@ export function computeContainerT2Capabilities(stats: Record<string, number>): {
     hullmass: number
     capacity: number
 } {
-    const strength = stats['strength'] ?? 0
-    const density = stats['density'] ?? 0
-    const hardness = stats['hardness'] ?? 0
-    const saturation = stats['saturation'] ?? 0
+    const strength = stats.strength
+    const density = stats.density
+    const hardness = stats.hardness
+    const saturation = stats.saturation
 
     const hullmass = 20000 + 50 * density