@shipload/sdk 2.0.0-rc5 → 2.0.0-rc6

package/src/data/items.json

@@ -1,17 +1,17 @@
 [
-    {"id": 26, "name": "Iron", "description": "A versatile metal used in hulls and structures.", "base_price": 125, "mass": 40000, "category": "metal", "tier": "t1", "color": "#B7410E"},
-    {"id": 13, "name": "Aluminum", "description": "A lightweight metal for structural components.", "base_price": 175, "mass": 27000, "category": "metal", "tier": "t2", "color": "#A8B5C2"},
-    {"id": 24, "name": "Chromium", "description": "A hard, corrosion-resistant alloy metal.", "base_price": 350, "mass": 52000, "category": "metal", "tier": "t3", "color": "#D4E6F1"},
-    {"id": 29, "name": "Copper", "description": "A conductive metal for electronics and wiring.", "base_price": 100, "mass": 60000, "category": "precious", "tier": "t1", "color": "#B87333"},
-    {"id": 47, "name": "Silver", "description": "A high-conductivity metal for precision components.", "base_price": 300, "mass": 55000, "category": "precious", "tier": "t2", "color": "#C0C0C0"},
-    {"id": 79, "name": "Gold", "description": "A corrosion-proof metal for advanced electronics.", "base_price": 500, "mass": 70000, "category": "precious", "tier": "t3", "color": "#FFD700"},
-    {"id": 1, "name": "Hydrogen", "description": "A lightweight gas used for fuel cells and propulsion.", "base_price": 50, "mass": 15000, "category": "gas", "tier": "t1", "color": "#7EC8E3"},
-    {"id": 2, "name": "Helium", "description": "An inert noble gas used in energy systems.", "base_price": 75, "mass": 2000, "category": "gas", "tier": "t2", "color": "#F5E6CC"},
-    {"id": 18, "name": "Argon", "description": "A noble gas used in industrial and energy applications.", "base_price": 250, "mass": 8000, "category": "gas", "tier": "t3", "color": "#9B59B6"},
-    {"id": 14, "name": "Silicon", "description": "A semiconductor used in sensors and computing.", "base_price": 150, "mass": 28000, "category": "mineral", "tier": "t1", "color": "#B8A9C9"},
-    {"id": 1000, "name": "Quartz", "description": "A crystalline mineral for sensors and optics.", "base_price": 200, "mass": 35000, "category": "mineral", "tier": "t2", "color": "#E8D5B7"},
-    {"id": 1001, "name": "Sapphire", "description": "A precious crystal for precision instruments.", "base_price": 400, "mass": 45000, "category": "mineral", "tier": "t3", "color": "#0F52BA"},
-    {"id": 6, "name": "Carbon", "description": "A versatile element for life support and coatings.", "base_price": 100, "mass": 12000, "category": "organic", "tier": "t1", "color": "#4A4A4A"},
-    {"id": 1003, "name": "Biomass", "description": "Organic matter for life support systems.", "base_price": 100, "mass": 30000, "category": "organic", "tier": "t2", "color": "#8B4513"},
-    {"id": 1002, "name": "Resin", "description": "A fossilized organic compound for coatings and sealants.", "base_price": 300, "mass": 25000, "category": "organic", "tier": "t3", "color": "#DAA520"}
+    {"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

@@ -25,3 +25,4 @@ export {
 } from './resources'
 
 export * from './stats'
+export * from './crafting'

package/src/derivation/stats.ts

@@ -9,33 +9,109 @@ export interface StatDefinition {
 }
 
 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},
+    {
+        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'},
+    {
+        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'},
+    {
+        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'},
+    {
+        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'},
+    {
+        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[]> = {

package/src/derivation/stratum.ts

@@ -85,7 +85,7 @@ export function deriveStratum(
 
     let depthBonus = 0
     if (stratum > 1) {
-        depthBonus = 50 * Math.log(stratum) / Math.log(65535)
+        depthBonus = (50 * Math.log(stratum)) / Math.log(65535)
     }
     const richness = Math.min(Math.floor(baseRichness + depthBonus), 1000)
 
@@ -95,7 +95,7 @@ export function deriveStratum(
 export function deriveResourceStats(seed: bigint): ResourceStats {
     const seedBytes = new Uint8Array(8)
     for (let i = 7; i >= 0; i--) {
-        seedBytes[i] = Number(seed & 0xFFn)
+        seedBytes[i] = Number(seed & 0xffn)
         seed >>= 8n
     }
     const hashResult = Checksum256.hash(Bytes.from(seedBytes))

package/src/entities/cargo-utils.ts

@@ -12,12 +12,6 @@ export function totalCargoMass(cargo: EntityInventory[]): UInt64 {
     }, UInt64.from(0))
 }
 
-export function cargoValue(cargo: EntityInventory[]): UInt64 {
-    return cargo.reduce((sum, c) => {
-        return sum.adding(c.totalCost)
-    }, UInt64.from(0))
-}
-
 export function getCargoForItem(
     cargo: EntityInventory[],
     goodId: UInt64Type
@@ -47,84 +41,33 @@ export function isFull(currentMass: UInt64, maxCapacity: UInt64): boolean {
     return currentMass.gte(maxCapacity)
 }
 
-export interface SaleValue {
-    revenue: UInt64
-    profit: UInt64
-    cost: UInt64
-}
-
-export function calculateSaleValue(
-    cargo: ServerContract.Types.cargo_item[],
-    prices: Map<number, UInt64>
-): SaleValue {
-    if (cargo.length === 0) {
-        return {revenue: UInt64.from(0), profit: UInt64.from(0), cost: UInt64.from(0)}
-    }
-
-    let revenue = UInt64.from(0)
-    let cost = UInt64.from(0)
-
-    for (const item of cargo) {
-        if (UInt32.from(item.quantity).equals(UInt32.from(0))) continue
-
-        const goodId = Number(item.item_id)
-        const salePrice = prices.get(goodId)
-
-        if (salePrice) {
-            revenue = revenue.adding(salePrice.multiplying(item.quantity))
-        }
-
-        cost = cost.adding(item.unit_cost.multiplying(item.quantity))
-    }
-
-    const profit = revenue.gte(cost) ? revenue.subtracting(cost) : UInt64.from(0)
-
-    return {
-        revenue,
-        profit,
-        cost,
-    }
-}
-
-export function calculateSaleValueFromArray(
-    cargo: ServerContract.Types.cargo_item[],
-    prices: UInt64[]
-): SaleValue {
-    const priceMap = new Map<number, UInt64>()
-    prices.forEach((price, index) => {
-        priceMap.set(index, price)
-    })
-    return calculateSaleValue(cargo, priceMap)
-}
-
-export function afterSellItems(
+export function afterRemoveItems(
     cargo: ServerContract.Types.cargo_item[],
-    goodsToSell: Array<{goodId: number; quantity: number}>
+    goodsToRemove: Array<{goodId: number; quantity: number}>
 ): EntityInventory[] {
     if (cargo.length === 0) {
         return []
     }
 
     return cargo.map((item) => {
-        const saleItem = goodsToSell.find((s) => Number(item.item_id) === s.goodId)
-        if (!saleItem) {
+        const removeItem = goodsToRemove.find((s) => Number(item.item_id) === s.goodId)
+        if (!removeItem) {
             return new EntityInventory(item)
         }
 
         const currentQty = Number(item.quantity)
-        const newQty = Math.max(0, currentQty - saleItem.quantity)
+        const newQty = Math.max(0, currentQty - removeItem.quantity)
 
         return new EntityInventory(
             ServerContract.Types.cargo_item.from({
                 item_id: item.item_id,
                 quantity: UInt32.from(newQty),
-                unit_cost: item.unit_cost,
             })
         )
     })
 }
 
-export function afterSellAllItems(cargo: ServerContract.Types.cargo_item[]): EntityInventory[] {
+export function afterRemoveAllItems(cargo: ServerContract.Types.cargo_item[]): EntityInventory[] {
     if (cargo.length === 0) {
         return []
     }
@@ -135,7 +78,6 @@ export function afterSellAllItems(cargo: ServerContract.Types.cargo_item[]): Ent
                 ServerContract.Types.cargo_item.from({
                     item_id: item.item_id,
                     quantity: UInt32.from(0),
-                    unit_cost: item.unit_cost,
                 })
             )
     )

package/src/entities/container.ts

@@ -68,3 +68,21 @@ export class Container extends ServerContract.Types.entity_info {
         return this.coordinates.z?.toNumber() || 0
     }
 }
+
+export function computeContainerCapabilities(stats: Record<string, number>): {
+	hullmass: number
+	capacity: number
+} {
+	const density = stats['density'] ?? 500
+	const strength = stats['strength'] ?? 500
+	const ductility = stats['ductility'] ?? 500
+	const purity = stats['purity'] ?? 500
+
+	const hullmass = 25000 + 75 * density
+
+	const statSum = strength + ductility + purity
+	const exponent = statSum / 2997
+	const capacity = Math.floor(1000000 * Math.pow(10, exponent))
+
+	return {hullmass, capacity}
+}

package/src/entities/entity-inventory.ts

@@ -29,10 +29,6 @@ export class EntityInventory extends ServerContract.Types.cargo_item {
         return UInt64.from(this.unitMass).multiplying(this.quantity)
     }
 
-    get totalCost(): UInt64 {
-        return this.unit_cost.multiplying(this.quantity)
-    }
-
     get hasCargo(): boolean {
         return UInt32.from(this.quantity).gt(UInt32.from(0))
     }

package/src/entities/inventory-accessor.ts

@@ -20,10 +20,6 @@ export class InventoryAccessor {
         return this.items.reduce((sum, c) => sum.adding(c.totalMass), UInt64.from(0))
     }
 
-    get totalValue(): UInt64 {
-        return this.items.reduce((sum, c) => sum.adding(c.totalCost), UInt64.from(0))
-    }
-
     forItem(goodId: UInt64Type): EntityInventory | undefined {
         return this.items.find((c) => c.item_id.equals(goodId))
     }