@shipload/sdk 2.0.0-rc20 → 2.0.0-rc21

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)
 }

package/src/scheduling/projection.ts

@@ -13,16 +13,10 @@ import {
     RECIPE_INPUTS_EXCESS,
     RECIPE_INPUTS_INSUFFICIENT,
     RECIPE_INPUTS_INVALID,
-    RECIPE_INPUTS_MIXED,
     RECIPE_NOT_FOUND,
     SHIP_CARGO_NOT_LOADED,
 } from '../errors'
-import {
-    getComponentById,
-    getEntityRecipeByItemId,
-    getModuleRecipeByItemId,
-    RecipeInput,
-} from '../data/recipes'
+import {getRecipe, RecipeInput} from '../data/recipes-runtime'
 import {getItem} from '../market/items'
 import {distanceBetweenCoordinates, lerp} from '../travel/travel'
 import {
@@ -296,14 +290,9 @@ export function projectEntity(entity: Projectable, options?: ProjectionOptions):
     return projected
 }
 
-function getRecipeForOutput(outputItemId: number): RecipeInput[] | undefined {
-    const component = getComponentById(outputItemId)
-    if (component) return component.recipe
-    const moduleRecipe = getModuleRecipeByItemId(outputItemId)
-    if (moduleRecipe) return moduleRecipe.recipe
-    const entityRecipe = getEntityRecipeByItemId(outputItemId)
-    if (entityRecipe) return entityRecipe.recipe
-    return undefined
+function getRecipeInputsForOutput(outputItemId: number): RecipeInput[] | undefined {
+    const recipe = getRecipe(outputItemId)
+    return recipe?.inputs
 }
 
 function validateCraftTask(task: ServerContract.Types.task, projected: ProjectedEntity): void {
@@ -313,7 +302,7 @@ function validateCraftTask(task: ServerContract.Types.task, projected: Projected
     const inputs = task.cargo.slice(0, -1)
     const craftQuantity = output.quantity.toNumber()
 
-    const recipe = getRecipeForOutput(output.item_id.toNumber())
+    const recipe = getRecipeInputsForOutput(output.item_id.toNumber())
     if (!recipe) throw new Error(RECIPE_NOT_FOUND)
 
     const groupedInputs: ServerContract.Types.cargo_item[][] = recipe.map(() => [])
@@ -321,15 +310,15 @@ function validateCraftTask(task: ServerContract.Types.task, projected: Projected
         let matched = false
         for (let ri = 0; ri < recipe.length; ri++) {
             const req = recipe[ri]
-            if (req.itemId && req.itemId > 0) {
+            if ('itemId' in req) {
                 if (input.item_id.toNumber() === req.itemId) {
                     groupedInputs[ri].push(input)
                     matched = true
                     break
                 }
-            } else if (req.category) {
+            } else {
                 const item = getItem(input.item_id)
-                if (item.category === req.category) {
+                if (item.category === req.category && item.tier === req.tier) {
                     groupedInputs[ri].push(input)
                     matched = true
                     break
@@ -348,15 +337,6 @@ function validateCraftTask(task: ServerContract.Types.task, projected: Projected
         const required = recipe[ri].quantity * craftQuantity
         if (provided < required) throw new Error(RECIPE_INPUTS_INSUFFICIENT)
         if (provided !== required) throw new Error(RECIPE_INPUTS_EXCESS)
-
-        if (!recipe[ri].itemId && stacks.length > 1) {
-            const firstItemId = stacks[0].item_id.toNumber()
-            for (let si = 1; si < stacks.length; si++) {
-                if (stacks[si].item_id.toNumber() !== firstItemId) {
-                    throw new Error(RECIPE_INPUTS_MIXED)
-                }
-            }
-        }
     }
 
     for (const input of inputs) {

package/src/travel/travel.ts

@@ -174,7 +174,8 @@ export function calc_ship_mass(ship: ShipLike, cargos: CargoMassInfo[]): UInt64
     }
 
     for (const cargo of cargos) {
-        mass.add(getItem(cargo.item_id).mass.multiplying(cargo.quantity))
+        const cargoMass = getItem(cargo.item_id).mass * Number(UInt32.from(cargo.quantity))
+        mass.add(UInt64.from(cargoMass))
     }
 
     return mass
@@ -195,8 +196,8 @@ export function calculateTransferTime(
         const qty = quantities?.get(Number(cargo.item_id)) ?? 0
         if (qty > 0) {
             const good_mass = getItem(cargo.item_id).mass
-            const cargo_mass = good_mass.multiplying(qty)
-            mass = UInt64.from(mass).adding(cargo_mass)
+            const cargo_mass = good_mass * qty
+            mass = UInt64.from(mass).adding(UInt64.from(cargo_mass))
         }
     }
 
@@ -249,12 +250,12 @@ export function calculateLoadTimeBreakdown(
             const good = getItem(cargo.item_id)
 
             if (loadQty > 0) {
-                const cargo_mass = good.mass.multiplying(loadQty)
-                mass_load = UInt64.from(mass_load).adding(cargo_mass)
+                const cargo_mass = good.mass * loadQty
+                mass_load = UInt64.from(mass_load).adding(UInt64.from(cargo_mass))
             }
             if (unloadQty > 0) {
-                const cargo_mass = good.mass.multiplying(unloadQty)
-                mass_unload = UInt64.from(mass_unload).adding(cargo_mass)
+                const cargo_mass = good.mass * unloadQty
+                mass_unload = UInt64.from(mass_unload).adding(UInt64.from(cargo_mass))
             }
         }
     }

package/src/types.ts

@@ -1,13 +1,4 @@
-import {
-    Int64Type,
-    Name,
-    Struct,
-    UInt16,
-    UInt16Type,
-    UInt32,
-    UInt32Type,
-    UInt64,
-} from '@wharfkit/antelope'
+import {Int64Type, Name, UInt16, UInt16Type, UInt32, UInt32Type, UInt64} from '@wharfkit/antelope'
 import {ServerContract} from './contracts'
 
 export const PRECISION = 10000
@@ -110,8 +101,20 @@ export interface Distance {
     distance: UInt16
 }
 
+export type ItemType = 'resource' | 'component' | 'module' | 'entity'
 export type ResourceCategory = 'ore' | 'crystal' | 'gas' | 'regolith' | 'biomass'
 export type ResourceTier = 't1' | 't2' | 't3' | 't4' | 't5'
+export type ModuleType =
+    | 'any'
+    | 'engine'
+    | 'generator'
+    | 'gatherer'
+    | 'loader'
+    | 'warp'
+    | 'crafter'
+    | 'launcher'
+    | 'storage'
+    | 'hauler'
 
 export const TIER_ADJECTIVES: Record<number, string> = {
     1: 'Crude',
@@ -138,27 +141,18 @@ export function tierNumber(tier: string): number {
     return Number(String(tier).replace(/^t/i, ''))
 }
 
-@Struct.type('item')
-export class Item extends Struct {
-    @Struct.field(UInt16)
-    id!: UInt16
-    @Struct.field('string')
-    name!: string
-    @Struct.field('string')
-    description!: string
-    @Struct.field(UInt32)
-    mass!: UInt32
-    @Struct.field('string')
-    category!: ResourceCategory
-    @Struct.field('string')
-    tier!: ResourceTier
-    @Struct.field('string')
-    color!: string
-
-    get displayName(): string {
-        if (this.name && this.name.length > 0) return this.name
-        const adj = TIER_ADJECTIVES[tierNumber(this.tier)] ?? 'Unknown'
-        const cat = CATEGORY_LABELS[this.category] ?? 'Resource'
-        return `${adj} ${cat}`
-    }
+export interface Item {
+    id: number
+    name: string
+    description: string
+    color: string
+    mass: number
+    type: ItemType
+    tier: number
+    category?: ResourceCategory
+    moduleType?: ModuleType
+}
+
+export function formatTier(tier: number): string {
+    return 'T' + tier
 }