@shipload/sdk 2.0.0-rc4 → 2.0.0-rc6

package/src/data/items.json

@@ -1,16 +1,17 @@
 [
-    {"id": 1, "name": "Hydrogen", "description": "A lightweight gas used for fuel cells and propulsion.", "base_price": 50, "mass": 15000, "category": "gas", "rarity": "common", "color": "#7EC8E3"},
-    {"id": 2, "name": "Helium", "description": "An inert noble gas used in energy systems.", "base_price": 75, "mass": 2000, "category": "gas", "rarity": "uncommon", "color": "#F5E6CC"},
-    {"id": 6, "name": "Carbon", "description": "A versatile element for life support and coatings.", "base_price": 100, "mass": 12000, "category": "organic", "rarity": "common", "color": "#4A4A4A"},
-    {"id": 14, "name": "Silicon", "description": "A semiconductor used in sensors and computing.", "base_price": 150, "mass": 28000, "category": "mineral", "rarity": "common", "color": "#B8A9C9"},
-    {"id": 18, "name": "Argon", "description": "A noble gas used in industrial and energy applications.", "base_price": 60, "mass": 8000, "category": "gas", "rarity": "rare", "color": "#9B59B6"},
-    {"id": 22, "name": "Titanium", "description": "A strong, lightweight metal for ship construction.", "base_price": 300, "mass": 48000, "category": "metal", "rarity": "rare", "color": "#C0C0C0"},
-    {"id": 26, "name": "Iron", "description": "A versatile metal used in hulls and structures.", "base_price": 125, "mass": 40000, "category": "metal", "rarity": "common", "color": "#B7410E"},
-    {"id": 29, "name": "Copper", "description": "A conductive metal for electronics and wiring.", "base_price": 200, "mass": 60000, "category": "metal", "rarity": "uncommon", "color": "#B87333"},
-    {"id": 54, "name": "Xenon", "description": "A rare noble gas for advanced propulsion systems.", "base_price": 175, "mass": 20000, "category": "gas", "rarity": "epic", "color": "#5B2C6F"},
-    {"id": 74, "name": "Tungsten", "description": "An extremely dense metal for heavy-duty applications.", "base_price": 500, "mass": 80000, "category": "metal", "rarity": "epic", "color": "#708090"},
-    {"id": 1000, "name": "Quartz", "description": "A crystalline mineral for sensors and optics.", "base_price": 200, "mass": 35000, "category": "mineral", "rarity": "uncommon", "color": "#E8D5B7"},
-    {"id": 1001, "name": "Sapphire", "description": "A precious crystal for precision instruments.", "base_price": 400, "mass": 45000, "category": "mineral", "rarity": "rare", "color": "#0F52BA"},
-    {"id": 1002, "name": "Polymers", "description": "Synthetic materials for coatings and consumables.", "base_price": 150, "mass": 25000, "category": "organic", "rarity": "rare", "color": "#2ECC71"},
-    {"id": 1003, "name": "Biomass", "description": "Organic matter for life support systems.", "base_price": 100, "mass": 30000, "category": "organic", "rarity": "uncommon", "color": "#8B4513"}
+    {"id": 26, "name": "Iron", "description": "A versatile metal used in hulls and structures.", "mass": 40000, "category": "metal", "tier": "t1", "color": "#B7410E"},
+    {"id": 13, "name": "Aluminum", "description": "A lightweight metal for structural components.", "mass": 27000, "category": "metal", "tier": "t2", "color": "#A8B5C2"},
+    {"id": 24, "name": "Chromium", "description": "A hard, corrosion-resistant alloy metal.", "mass": 52000, "category": "metal", "tier": "t3", "color": "#D4E6F1"},
+    {"id": 29, "name": "Copper", "description": "A conductive metal for electronics and wiring.", "mass": 60000, "category": "precious", "tier": "t1", "color": "#B87333"},
+    {"id": 47, "name": "Silver", "description": "A high-conductivity metal for precision components.", "mass": 55000, "category": "precious", "tier": "t2", "color": "#C0C0C0"},
+    {"id": 79, "name": "Gold", "description": "A corrosion-proof metal for advanced electronics.", "mass": 70000, "category": "precious", "tier": "t3", "color": "#FFD700"},
+    {"id": 1, "name": "Hydrogen", "description": "A lightweight gas used for fuel cells and propulsion.", "mass": 15000, "category": "gas", "tier": "t1", "color": "#7EC8E3"},
+    {"id": 2, "name": "Helium", "description": "An inert noble gas used in energy systems.", "mass": 2000, "category": "gas", "tier": "t2", "color": "#F5E6CC"},
+    {"id": 18, "name": "Argon", "description": "A noble gas used in industrial and energy applications.", "mass": 8000, "category": "gas", "tier": "t3", "color": "#9B59B6"},
+    {"id": 14, "name": "Silicon", "description": "A semiconductor used in sensors and computing.", "mass": 28000, "category": "mineral", "tier": "t1", "color": "#B8A9C9"},
+    {"id": 1000, "name": "Quartz", "description": "A crystalline mineral for sensors and optics.", "mass": 35000, "category": "mineral", "tier": "t2", "color": "#E8D5B7"},
+    {"id": 1001, "name": "Sapphire", "description": "A precious crystal for precision instruments.", "mass": 45000, "category": "mineral", "tier": "t3", "color": "#0F52BA"},
+    {"id": 6, "name": "Carbon", "description": "A versatile element for life support and coatings.", "mass": 12000, "category": "organic", "tier": "t1", "color": "#4A4A4A"},
+    {"id": 1003, "name": "Biomass", "description": "Organic matter for life support systems.", "mass": 30000, "category": "organic", "tier": "t2", "color": "#8B4513"},
+    {"id": 1002, "name": "Resin", "description": "A fossilized organic compound for coatings and sealants.", "mass": 25000, "category": "organic", "tier": "t3", "color": "#DAA520"}
 ]

package/src/data/recipes.ts

@@ -0,0 +1,129 @@
+import type {ResourceCategory} from '../types'
+
+export const ITEM_HULL_PLATES = 10001
+export const ITEM_CARGO_LINING = 10002
+export const ITEM_CONTAINER_PACKED = 10003
+
+export interface RecipeInput {
+	category?: ResourceCategory
+	itemId?: number
+	quantity: number
+}
+
+export interface ComponentStat {
+	key: string
+	source: ResourceCategory
+}
+
+export interface ComponentDefinition {
+	id: number
+	name: string
+	description: string
+	color: string
+	mass: number
+	stats: ComponentStat[]
+	recipe: RecipeInput[]
+	usedIn: {type: 'entity'; name: string}[]
+}
+
+export interface EntityRecipe {
+	id: string
+	name: string
+	description: string
+	color: string
+	packedItemId: number
+	recipe: RecipeInput[]
+	stats: {key: string; sourceComponentId: number; sourceStatKey: string}[]
+}
+
+export interface CraftableItem {
+	type: 'component' | 'entity'
+	id: number | string
+	name: string
+	description: string
+	color: string
+}
+
+export const components: ComponentDefinition[] = [
+	{
+		id: ITEM_HULL_PLATES,
+		name: 'Hull Plates',
+		description: 'Structural plating formed from metal. Used in hulls, containers, and frames.',
+		color: '#7B8D9E',
+		mass: 50000,
+		stats: [
+			{key: 'strength', source: 'metal'},
+			{key: 'density', source: 'metal'},
+		],
+		recipe: [{category: 'metal', quantity: 40}],
+		usedIn: [{type: 'entity', name: 'Container'}],
+	},
+	{
+		id: ITEM_CARGO_LINING,
+		name: 'Cargo Lining',
+		description:
+			'Precision-formed composite lining for cargo storage. Combines precious metal shaping with organic sealing.',
+		color: '#D4A843',
+		mass: 30000,
+		stats: [
+			{key: 'ductility', source: 'precious'},
+			{key: 'purity', source: 'organic'},
+		],
+		recipe: [
+			{category: 'precious', quantity: 10},
+			{category: 'organic', quantity: 20},
+		],
+		usedIn: [{type: 'entity', name: 'Container'}],
+	},
+]
+
+export const entityRecipes: EntityRecipe[] = [
+	{
+		id: 'container',
+		name: 'Container',
+		description: 'Passive floating cargo storage in space. Towed by ships.',
+		color: '#7B8D9E',
+		packedItemId: ITEM_CONTAINER_PACKED,
+		recipe: [
+			{itemId: ITEM_HULL_PLATES, quantity: 6},
+			{itemId: ITEM_CARGO_LINING, quantity: 2},
+		],
+		stats: [
+			{key: 'strength', sourceComponentId: ITEM_HULL_PLATES, sourceStatKey: 'strength'},
+			{key: 'density', sourceComponentId: ITEM_HULL_PLATES, sourceStatKey: 'density'},
+			{key: 'ductility', sourceComponentId: ITEM_CARGO_LINING, sourceStatKey: 'ductility'},
+			{key: 'purity', sourceComponentId: ITEM_CARGO_LINING, sourceStatKey: 'purity'},
+		],
+	},
+]
+
+export function getComponentById(id: number): ComponentDefinition | undefined {
+	return components.find((c) => c.id === id)
+}
+
+export function getEntityRecipe(id: string): EntityRecipe | undefined {
+	return entityRecipes.find((r) => r.id === id)
+}
+
+export function getEntityRecipeByItemId(itemId: number): EntityRecipe | undefined {
+	return entityRecipes.find((r) => r.packedItemId === itemId)
+}
+
+export function getAllCraftableItems(): CraftableItem[] {
+	const items: CraftableItem[] = []
+	for (const comp of components) {
+		items.push({type: 'component', id: comp.id, name: comp.name, description: comp.description, color: comp.color})
+	}
+	for (const entity of entityRecipes) {
+		items.push({type: 'entity', id: entity.id, name: entity.name, description: entity.description, color: entity.color})
+	}
+	return items
+}
+
+export function getComponentsForCategory(category: ResourceCategory): ComponentDefinition[] {
+	return components.filter((c) => c.recipe.some((r) => r.category === category))
+}
+
+export function getComponentsForStat(statKey: string): ComponentDefinition[] {
+	return components.filter((c) => c.stats.some((s) => s.key === statKey))
+}

package/src/derivation/crafting.ts

@@ -0,0 +1,120 @@
+import type {ResourceCategory} from '../types'
+import {
+	components,
+	entityRecipes,
+	getComponentById,
+	getEntityRecipe,
+} from '../data/recipes'
+
+export interface StackInput {
+	quantity: number
+	stats: Record<string, number>
+}
+
+export interface CategoryStacks {
+	category: ResourceCategory
+	stacks: StackInput[]
+}
+
+export function encodeStats(values: number[]): bigint {
+	let seed = 0n
+	for (let i = 0; i < values.length && i < 6; i++) {
+		seed |= BigInt(values[i] & 0x3ff) << BigInt(i * 10)
+	}
+	return seed
+}
+
+export function decodeStats(seed: bigint, count: number): number[] {
+	const stats: number[] = []
+	for (let i = 0; i < count; i++) {
+		stats.push(Number((seed >> BigInt(i * 10)) & 0x3ffn))
+	}
+	return stats
+}
+
+export function decodeCraftedItemStats(itemId: number, seed: bigint): Record<string, number> {
+	const comp = getComponentById(itemId)
+	if (comp) {
+		const values = decodeStats(seed, comp.stats.length)
+		const result: Record<string, number> = {}
+		for (let i = 0; i < comp.stats.length; i++) {
+			result[comp.stats[i].key] = values[i]
+		}
+		return result
+	}
+
+	const entityRecipe = entityRecipes.find((r) => r.packedItemId === itemId)
+	if (entityRecipe) {
+		const values = decodeStats(seed, entityRecipe.stats.length)
+		const result: Record<string, number> = {}
+		for (let i = 0; i < entityRecipe.stats.length; i++) {
+			result[entityRecipe.stats[i].key] = values[i]
+		}
+		return result
+	}
+
+	return {}
+}
+
+export function blendStacks(stacks: StackInput[], statKey: string): number {
+	let totalQty = 0
+	let weightedSum = 0
+	for (const stack of stacks) {
+		const val = stack.stats[statKey] ?? 0
+		weightedSum += val * stack.quantity
+		totalQty += stack.quantity
+	}
+	if (totalQty === 0) return 0
+	return Math.round(weightedSum / totalQty)
+}
+
+export function computeComponentStats(
+	componentId: number,
+	categoryStacks: CategoryStacks[]
+): {key: string; value: number}[] {
+	const comp = getComponentById(componentId)
+	if (!comp) return []
+
+	return comp.stats.map((statDef) => {
+		const matching = categoryStacks.find((cs) => cs.category === statDef.source)
+		const value = matching ? blendStacks(matching.stacks, statDef.key) : 0
+		return {key: statDef.key, value: Math.max(1, Math.min(999, value))}
+	})
+}
+
+export function blendComponentStacks(
+	stacks: {quantity: number; stats: Record<string, number>}[]
+): Record<string, number> {
+	if (stacks.length === 0) return {}
+	const allKeys = new Set<string>()
+	for (const s of stacks) {
+		for (const k of Object.keys(s.stats)) allKeys.add(k)
+	}
+	const result: Record<string, number> = {}
+	for (const key of allKeys) {
+		result[key] = blendStacks(
+			stacks.map((s) => ({quantity: s.quantity, stats: s.stats})),
+			key
+		)
+	}
+	return result
+}
+
+export function computeEntityStats(
+	entityRecipeId: string,
+	componentStacks: Record<number, {quantity: number; stats: Record<string, number>}[]>
+): {key: string; value: number}[] {
+	const recipe = getEntityRecipe(entityRecipeId)
+	if (!recipe) return []
+
+	const blendedByComponent: Record<number, Record<string, number>> = {}
+	for (const [compId, stacks] of Object.entries(componentStacks)) {
+		blendedByComponent[Number(compId)] = blendComponentStacks(stacks)
+	}
+
+	return recipe.stats.map((stat) => {
+		const blended = blendedByComponent[stat.sourceComponentId] ?? {}
+		const value = blended[stat.sourceStatKey] ?? 0
+		return {key: stat.key, value: Math.max(1, Math.min(999, value))}
+	})
+}

package/src/derivation/index.ts

@@ -6,13 +6,13 @@ export {
     getResourceWeight,
     getLocationCandidates,
     getDepthThreshold,
-    getResourceRarity,
+    getResourceTier,
     depthScaleFactor,
-    DEPTH_THRESHOLD_COMMON,
-    DEPTH_THRESHOLD_UNCOMMON,
-    DEPTH_THRESHOLD_RARE,
-    DEPTH_THRESHOLD_EPIC,
-    DEPTH_THRESHOLD_LEGENDARY,
+    DEPTH_THRESHOLD_T1,
+    DEPTH_THRESHOLD_T2,
+    DEPTH_THRESHOLD_T3,
+    DEPTH_THRESHOLD_T4,
+    DEPTH_THRESHOLD_T5,
     LOCATION_MIN_DEPTH,
     LOCATION_MAX_DEPTH,
     YIELD_THRESHOLD,
@@ -23,3 +23,6 @@ export {
     PLANET_SUBTYPE_OCEAN,
     PLANET_SUBTYPE_INDUSTRIAL,
 } from './resources'
+
+export * from './stats'
+export * from './crafting'

package/src/derivation/resources.ts

@@ -1,10 +1,10 @@
-import {ResourceRarity} from '../types'
+import {ResourceTier} from '../types'
 
-export const DEPTH_THRESHOLD_COMMON = 0
-export const DEPTH_THRESHOLD_UNCOMMON = 2000
-export const DEPTH_THRESHOLD_RARE = 10000
-export const DEPTH_THRESHOLD_EPIC = 30000
-export const DEPTH_THRESHOLD_LEGENDARY = 55000
+export const DEPTH_THRESHOLD_T1 = 0
+export const DEPTH_THRESHOLD_T2 = 2000
+export const DEPTH_THRESHOLD_T3 = 10000
+export const DEPTH_THRESHOLD_T4 = 30000
+export const DEPTH_THRESHOLD_T5 = 55000
 
 export const LOCATION_MIN_DEPTH = 500
 export const LOCATION_MAX_DEPTH = 65535
@@ -20,84 +20,85 @@ export const PLANET_SUBTYPE_INDUSTRIAL = 5
 
 interface ResourceEntry {
     id: number
-    rarity: ResourceRarity
+    tier: ResourceTier
 }
 
 const RESOURCE_CATALOG: ResourceEntry[] = [
-    {id: 26, rarity: 'common'},
-    {id: 1, rarity: 'common'},
-    {id: 14, rarity: 'common'},
-    {id: 6, rarity: 'common'},
-    {id: 29, rarity: 'uncommon'},
-    {id: 2, rarity: 'uncommon'},
-    {id: 1000, rarity: 'uncommon'},
-    {id: 1003, rarity: 'uncommon'},
-    {id: 22, rarity: 'rare'},
-    {id: 18, rarity: 'rare'},
-    {id: 1001, rarity: 'rare'},
-    {id: 1002, rarity: 'rare'},
-    {id: 74, rarity: 'epic'},
-    {id: 54, rarity: 'epic'},
+    {id: 26, tier: 't1'},
+    {id: 13, tier: 't2'},
+    {id: 24, tier: 't3'},
+    {id: 29, tier: 't1'},
+    {id: 47, tier: 't2'},
+    {id: 79, tier: 't3'},
+    {id: 1, tier: 't1'},
+    {id: 2, tier: 't2'},
+    {id: 18, tier: 't3'},
+    {id: 14, tier: 't1'},
+    {id: 1000, tier: 't2'},
+    {id: 1001, tier: 't3'},
+    {id: 6, tier: 't1'},
+    {id: 1003, tier: 't2'},
+    {id: 1002, tier: 't3'},
 ]
 
-export function getDepthThreshold(rarity: ResourceRarity): number {
-    switch (rarity) {
-        case 'common':
-            return DEPTH_THRESHOLD_COMMON
-        case 'uncommon':
-            return DEPTH_THRESHOLD_UNCOMMON
-        case 'rare':
-            return DEPTH_THRESHOLD_RARE
-        case 'epic':
-            return DEPTH_THRESHOLD_EPIC
-        case 'legendary':
-            return DEPTH_THRESHOLD_LEGENDARY
+export function getDepthThreshold(tier: ResourceTier): number {
+    switch (tier) {
+        case 't1':
+            return DEPTH_THRESHOLD_T1
+        case 't2':
+            return DEPTH_THRESHOLD_T2
+        case 't3':
+            return DEPTH_THRESHOLD_T3
+        case 't4':
+            return DEPTH_THRESHOLD_T4
+        case 't5':
+            return DEPTH_THRESHOLD_T5
     }
 }
 
-export function getResourceRarity(itemId: number): ResourceRarity {
+export function getResourceTier(itemId: number): ResourceTier {
     const entry = RESOURCE_CATALOG.find((r) => r.id === itemId)
-    return entry ? entry.rarity : 'legendary'
+    return entry ? entry.tier : 't5'
 }
 
 export function getResourceWeight(itemId: number, stratum: number): number {
-    const rarity = getResourceRarity(itemId)
-    const threshold = getDepthThreshold(rarity)
+    const tier = getResourceTier(itemId)
+    const threshold = getDepthThreshold(tier)
     if (stratum < threshold) return 0
 
     const depthAbove = stratum - threshold
 
-    switch (rarity) {
-        case 'common':
+    switch (tier) {
+        case 't1':
             if (stratum < 2000) return 100
             if (stratum < 10000) return 80
             if (stratum < 30000) return 50
             return 30
-        case 'uncommon':
+        case 't2':
             if (depthAbove < 3000) return 40
             if (depthAbove < 8000) return 60
             return 50
-        case 'rare':
+        case 't3':
             if (depthAbove < 5000) return 20
             if (depthAbove < 15000) return 35
             return 40
-        case 'epic':
+        case 't4':
             if (depthAbove < 10000) return 10
             if (depthAbove < 25000) return 20
             return 30
-        case 'legendary':
+        case 't5':
             return 10
     }
 }
 
-const ASTEROID_RESOURCES = [26, 29, 22, 74, 14, 1000, 1001]
-const NEBULA_RESOURCES = [1, 2, 18, 54]
-const GAS_GIANT_RESOURCES = [1, 2, 18, 54]
-const ROCKY_RESOURCES = [26, 29, 22, 74, 6, 1003, 1002]
-const TERRESTRIAL_RESOURCES = [6, 1003, 1002, 1001]
-const ICY_RESOURCES = [6, 14, 1000, 1001, 18]
-const OCEAN_RESOURCES = [1, 2, 1003, 1002]
-const INDUSTRIAL_RESOURCES = [26, 29, 22, 74, 14, 1000, 54]
+const ASTEROID_RESOURCES = [26, 13, 24, 29, 47]
+const NEBULA_RESOURCES = [47, 79, 1, 2, 18]
+const GAS_GIANT_RESOURCES = [1, 2, 18, 14, 6]
+const ROCKY_RESOURCES = [26, 13, 24, 14, 1000, 1001, 1002]
+const TERRESTRIAL_RESOURCES = [29, 47, 14, 1000, 6, 1003, 1002]
+const ICY_RESOURCES = [26, 1, 2, 14, 1001, 6, 1003]
+const OCEAN_RESOURCES = [29, 79, 1, 18, 6, 1003, 1002]
+const INDUSTRIAL_RESOURCES = [26, 13, 24, 29, 79, 1000, 1001]
 
 export function getLocationCandidates(locationType: number, subtype: number): number[] {
     if (locationType === 2) return ASTEROID_RESOURCES
@@ -128,8 +129,8 @@ export function getEligibleResources(
 ): number[] {
     const candidates = getLocationCandidates(locationType, subtype)
     return candidates.filter((itemId) => {
-        const rarity = getResourceRarity(itemId)
-        const threshold = getDepthThreshold(rarity)
+        const tier = getResourceTier(itemId)
+        const threshold = getDepthThreshold(tier)
         return stratum >= threshold
     })
 }

package/src/derivation/stats.ts

@@ -0,0 +1,146 @@
+import type {ResourceCategory} from '../types'
+
+export interface StatDefinition {
+    key: string
+    label: string
+    abbreviation: string
+    purpose: string
+    inverted?: boolean
+}
+
+const METAL_STATS: StatDefinition[] = [
+    {
+        key: 'strength',
+        label: 'Strength',
+        abbreviation: 'STR',
+        purpose: 'Raw structural/mechanical force',
+    },
+    {
+        key: 'tolerance',
+        label: 'Tolerance',
+        abbreviation: 'TOL',
+        purpose: 'Ability to withstand heat, pressure, and stress extremes',
+    },
+    {
+        key: 'density',
+        label: 'Density',
+        abbreviation: 'DEN',
+        purpose: 'Mass per unit',
+        inverted: true,
+    },
+]
+
+const PRECIOUS_STATS: StatDefinition[] = [
+    {
+        key: 'conductivity',
+        label: 'Conductivity',
+        abbreviation: 'CON',
+        purpose: 'Efficiency of energy/signal transfer',
+    },
+    {
+        key: 'ductility',
+        label: 'Ductility',
+        abbreviation: 'DUC',
+        purpose: 'Ability to be worked into fine, precise shapes',
+    },
+    {
+        key: 'reflectivity',
+        label: 'Reflectivity',
+        abbreviation: 'REF',
+        purpose: 'Surface quality for heat management and precision optics',
+    },
+]
+
+const GAS_STATS: StatDefinition[] = [
+    {
+        key: 'volatility',
+        label: 'Volatility',
+        abbreviation: 'VOL',
+        purpose: 'Energy release potential for propulsion and force',
+    },
+    {
+        key: 'reactivity',
+        label: 'Reactivity',
+        abbreviation: 'REA',
+        purpose: 'Chemical interaction speed for processing and penetration',
+    },
+    {
+        key: 'thermal',
+        label: 'Thermal',
+        abbreviation: 'THM',
+        purpose: 'Heat capacity for thermal management',
+    },
+]
+
+const MINERAL_STATS: StatDefinition[] = [
+    {
+        key: 'resonance',
+        label: 'Resonance',
+        abbreviation: 'RES',
+        purpose: 'Energy field interaction — storage, focusing, projection',
+    },
+    {
+        key: 'hardness',
+        label: 'Hardness',
+        abbreviation: 'HRD',
+        purpose: 'Resistance to wear — cutting surfaces, penetration',
+    },
+    {
+        key: 'clarity',
+        label: 'Clarity',
+        abbreviation: 'CLR',
+        purpose: 'Crystalline perfection — precision optics',
+    },
+]
+
+const ORGANIC_STATS: StatDefinition[] = [
+    {
+        key: 'plasticity',
+        label: 'Plasticity',
+        abbreviation: 'PLA',
+        purpose: 'Ease of reshaping — speeds processing',
+    },
+    {
+        key: 'insulation',
+        label: 'Insulation',
+        abbreviation: 'INS',
+        purpose: 'Energy containment — reduces energy loss',
+    },
+    {
+        key: 'purity',
+        label: 'Purity',
+        abbreviation: 'PUR',
+        purpose: 'Biological cleanliness — better composites and lubricants',
+    },
+]
+
+const STAT_MAP: Record<ResourceCategory, StatDefinition[]> = {
+    metal: METAL_STATS,
+    precious: PRECIOUS_STATS,
+    gas: GAS_STATS,
+    mineral: MINERAL_STATS,
+    organic: ORGANIC_STATS,
+}
+
+export function getStatDefinitions(category: ResourceCategory): StatDefinition[] {
+    return STAT_MAP[category]
+}
+
+export function getStatName(category: ResourceCategory, index: 0 | 1 | 2): StatDefinition {
+    return STAT_MAP[category][index]
+}
+
+export interface NamedStats {
+    definitions: StatDefinition[]
+    values: [number, number, number]
+}
+
+export function resolveStats(
+    category: ResourceCategory,
+    stats: {stat1: number; stat2: number; stat3: number}
+): NamedStats {
+    return {
+        definitions: STAT_MAP[category],
+        values: [stats.stat1, stats.stat2, stats.stat3],
+    }
+}