@shipload/sdk 1.0.0-next.7 → 1.0.0-next.70

package/src/nft/description.ts

@@ -1,106 +1,210 @@
 import {
     getModuleCapabilityType,
+    MODULE_BUILDER,
     MODULE_CRAFTER,
     MODULE_ENGINE,
     MODULE_GATHERER,
     MODULE_GENERATOR,
+    MODULE_BATTERY,
     MODULE_HAULER,
     MODULE_LOADER,
     MODULE_STORAGE,
     MODULE_WARP,
 } from '../capabilities/modules'
-import {
-    ITEM_CONTAINER_T1_PACKED,
-    ITEM_CONTAINER_T2_PACKED,
-    ITEM_CRAFTER_T1,
-    ITEM_ENGINE_T1,
-    ITEM_GATHERER_T1,
-    ITEM_GENERATOR_T1,
-    ITEM_HAULER_T1,
-    ITEM_LOADER_T1,
-    ITEM_SHIP_T1_PACKED,
-    ITEM_STORAGE_T1,
-    ITEM_WAREHOUSE_T1_PACKED,
-    ITEM_WARP_T1,
-} from '../data/item-ids'
+import {getKindMeta, getTemplateMeta} from '../data/kind-registry'
 import {decodeStat} from '../derivation/crafting'
-import {gathererDepthForTier} from '../entities/ship-deploy'
-import {getItem} from '../data/catalog'
+import {
+    gathererDepthForTier,
+    computeGathererYield,
+    moduleTierPct,
+    ENGINE_THRUST_TIER_PCT,
+    GENERATOR_CAPACITY_TIER_PCT,
+    GENERATOR_RECHARGE_TIER_PCT,
+    CRAFTER_SPEED_TIER_PCT,
+    BUILDER_SPEED_TIER_PCT,
+    WARP_RANGE_TIER_PCT,
+    LOADER_THRUST_TIER_PCT,
+    CARGO_BAY_CAPACITY_TIER_PCT,
+    BATTERY_CAPACITY_TIER_PCT,
+} from '../derivation/capabilities'
+import {getItem, tryGetItem} from '../data/catalog'
+import {MASS_UNITS_PER_TONNE, type ModuleType} from '../types'
+import {ENTITY_SHIP, getPackedEntityType} from '../data/kind-registry'
+import {getBaseHullmassFor} from '../derivation/capabilities'
+import {computeEffectiveModuleStat} from '../derivation/stat-scaling'
 
 function idiv(a: number, b: number): number {
     return Math.floor(a / b)
 }
 
-export function computeBaseHullmass(stats: bigint): number {
+export function toWholeEnergy(milli: number): number {
+    return idiv(milli + 500, 1000)
+}
+
+export function formatMassTonnes(mass: number): string {
+    return `${idiv(mass, MASS_UNITS_PER_TONNE)}.${mass % MASS_UNITS_PER_TONNE} t`
+}
+
+function isShipHull(itemId: number): boolean {
+    return getPackedEntityType(itemId)?.equals(ENTITY_SHIP) ?? false
+}
+
+function sumPackedShipChannels(stats: bigint): number {
+    let sum = 0
+    for (let slot = 0; slot < 5; slot++) sum += decodeStat(stats, slot)
+    return sum
+}
+
+export function computeBaseHullmass(itemId: number, stats: bigint): number {
+    if (isShipHull(itemId)) {
+        return Math.floor(
+            (getBaseHullmassFor(itemId) * (10_000 - sumPackedShipChannels(stats))) / 10_000
+        )
+    }
     const density = decodeStat(stats, 1)
-    return 25000 + 75 * density
+    return Math.floor((getBaseHullmassFor(itemId) * (2000 - density)) / 2000)
 }
 
 export function computeBaseCapacityShip(stats: bigint): number {
-    const s = decodeStat(stats, 0) + decodeStat(stats, 2) + decodeStat(stats, 3)
-    return Math.floor(1_000_000 * 10 ** (s / 2997))
+    return Math.floor(50_000 * 6 ** (sumPackedShipChannels(stats) / 4995))
+}
+
+export function computeBaseCapacityContainer(stats: bigint): number {
+    const s = decodeStat(stats, 0) + decodeStat(stats, 2)
+    return Math.floor(220_000 * 6 ** (s / 1998))
 }
 
 export function computeBaseCapacityWarehouse(stats: bigint): number {
-    const s = decodeStat(stats, 0) + decodeStat(stats, 2) + decodeStat(stats, 3)
-    return Math.floor(20_000_000 * 10 ** (s / 2997))
+    const s = decodeStat(stats, 0) + decodeStat(stats, 2)
+    return Math.floor(1_000_000 * 6 ** (s / 1998))
 }
 
-export const computeEngineThrust = (vol: number): number => 400 + idiv(vol * 3, 4)
-export const computeEngineDrain = (thm: number): number => Math.max(30, 50 - idiv(thm, 70))
-export const computeGeneratorCap = (com: number): number => 300 + idiv(com, 6)
-export const computeGeneratorRech = (fin: number): number => 1 + idiv(fin * 3, 1000)
-export const computeGathererYield = (str: number): number => 200 + str
+export function computeBaseCapacityWorkshop(stats: bigint): number {
+    const s = decodeStat(stats, 0) + decodeStat(stats, 2)
+    return Math.floor(50_000 * 6 ** (s / 1998))
+}
+
+export function computeBaseCapacityDepot(stats: bigint): number {
+    const s = decodeStat(stats, 0) + decodeStat(stats, 2)
+    return Math.floor(500_000 * 6 ** (s / 1998))
+}
+
+const CAPACITY_FN_BY_KIND: Record<string, (stats: bigint) => number> = {
+    ship: computeBaseCapacityShip,
+    warehouse: computeBaseCapacityWarehouse,
+    workshop: computeBaseCapacityWorkshop,
+    extractor: computeBaseCapacityContainer,
+    factory: computeBaseCapacityContainer,
+    builddock: computeBaseCapacityContainer,
+    mdriver: computeBaseCapacityContainer,
+    mcatcher: computeBaseCapacityContainer,
+    container: computeBaseCapacityContainer,
+    nexus: computeBaseCapacityContainer,
+    depot: computeBaseCapacityDepot,
+}
+
+export function computeBaseCapacityForEntity(itemId: number, stats: bigint): number {
+    const kind = getTemplateMeta(itemId)?.kind
+    if (!kind) return 0
+    return CAPACITY_FN_BY_KIND[kind.toString()]?.(stats) ?? 0
+}
+
+export const computeEngineThrust = (vol: number, tier: number): number =>
+    idiv((400 + idiv(vol * 3, 4)) * moduleTierPct(ENGINE_THRUST_TIER_PCT, tier), 100)
+export const computeEngineDrain = (thm: number): number => 2 * Math.max(30, 50 - idiv(thm, 70))
+export const ENGINE_DRAIN_BASE = 156
+export const ENGINE_DRAIN_REF_THRUST = 775
+export const ENGINE_DRAIN_REF_THM = 500
+
+export const computeTravelDrain = (totalThrust: number, avgThm: number): number => {
+    if (totalThrust <= 0) return 0
+    const thermalFactor = computeEngineDrain(avgThm) / computeEngineDrain(ENGINE_DRAIN_REF_THM)
+    const thrustFactor = Math.sqrt(ENGINE_DRAIN_REF_THRUST / totalThrust)
+    return Math.floor(ENGINE_DRAIN_BASE * 1000 * thermalFactor * thrustFactor)
+}
+export const computeGeneratorCap = (com: number, tier: number): number =>
+    idiv((1_300_000 + com * 500) * moduleTierPct(GENERATOR_CAPACITY_TIER_PCT, tier), 100)
+export const computeGeneratorRech = (fin: number, tier: number): number =>
+    idiv((2000 + fin * 6) * moduleTierPct(GENERATOR_RECHARGE_TIER_PCT, tier), 100)
 export const computeGathererDrain = (con: number): number =>
-    Math.max(250, 1250 - idiv(con * 25, 20))
+    2 * Math.max(250_000, 1_250_000 - con * 1250)
 export const computeGathererDepth = (tol: number, tier: number): number =>
     gathererDepthForTier(tol, tier)
-export const computeGathererSpeed = (ref: number): number => 100 + idiv(ref * 4, 5)
-export const computeLoaderMass = (ins: number): number => Math.max(200, 2000 - ins * 2)
-export const computeLoaderThrust = (pla: number): number => 1 + idiv(pla, 500)
-export const computeCrafterSpeed = (rea: number): number => 100 + idiv(rea * 4, 5)
-export const computeCrafterDrain = (fin: number): number => Math.max(5, 30 - idiv(fin, 33))
-export const computeHaulerCapacity = (fin: number): number => Math.max(1, 1 + idiv(fin, 400))
+export const computeLoaderMass = (ins: number): number => Math.max(2, 20 - idiv(ins, 50))
+export const computeLoaderThrust = (pla: number, tier: number): number =>
+    idiv((1 + idiv(pla * pla, 10000)) * moduleTierPct(LOADER_THRUST_TIER_PCT, tier), 100)
+export const computeCrafterSpeed = (rea: number, tier: number): number =>
+    idiv((100 + idiv(rea * 4, 5)) * moduleTierPct(CRAFTER_SPEED_TIER_PCT, tier), 100)
+export const computeCrafterDrain = (fin: number): number =>
+    Math.max(5000, 30000 - idiv(fin * 1000, 33))
+export const computeBuilderSpeed = (resonance: number, tier: number): number =>
+    idiv((100 + idiv(resonance * 4, 5)) * moduleTierPct(BUILDER_SPEED_TIER_PCT, tier), 100)
+export const computeBuilderDrain = (fineness: number): number =>
+    Math.max(5000, 30000 - idiv(fineness * 1000, 33))
+export const computeHaulerCapacity = (fin: number, tier: number): number =>
+    Math.max(tier, tier + idiv(fin, 400))
 export const computeHaulerEfficiency = (con: number): number => 2000 + con * 6
-export const computeHaulerDrain = (com: number): number => Math.max(3, 15 - idiv(com, 80))
-export const computeWarpRange = (stat: number): number => 100 + stat * 3
+export const supportDrainTierPercent = (tier: number): number => {
+    const clampedTier = Math.min(10, Math.max(1, Math.trunc(tier)))
+    return Math.max(50, 110 - clampedTier * 10)
+}
+const computeT1LogisticsDrain = (stat: number): number =>
+    Math.max(3000, 15000 - Math.min(12000, idiv(stat * 1000, 80)))
+export const computeHaulerDrain = (conductivity: number, tier: number): number =>
+    idiv(computeT1LogisticsDrain(conductivity) * supportDrainTierPercent(tier), 100)
+export const computeCargoBayDrain = (cohesion: number, tier: number): number =>
+    idiv(computeT1LogisticsDrain(cohesion) * 3 * supportDrainTierPercent(tier), 400)
+export const computeWarpRange = (stat: number, tier: number): number =>
+    idiv((100 + stat * 3) * moduleTierPct(WARP_RANGE_TIER_PCT, tier), 100)
+export const computeCargoBayCapacity = (
+    strength: number,
+    density: number,
+    hardness: number,
+    tier: number
+): number =>
+    idiv(
+        (100_000 + idiv((strength + density + hardness) * 500_000, 2997)) *
+            moduleTierPct(CARGO_BAY_CAPACITY_TIER_PCT, tier),
+        100
+    )
+export const computeBatteryBankCapacity = (
+    volatility: number,
+    thermal: number,
+    plasticity: number,
+    insulation: number,
+    tier: number
+): number =>
+    idiv(
+        (2_500_000 + idiv((volatility + thermal + plasticity + insulation) * 7_500_000, 3996)) *
+            moduleTierPct(BATTERY_CAPACITY_TIER_PCT, tier),
+        100
+    )
 
 export function entityDisplayName(itemId: number): string {
-    switch (itemId) {
-        case ITEM_SHIP_T1_PACKED:
-            return 'Ship'
-        case ITEM_WAREHOUSE_T1_PACKED:
-            return 'Warehouse'
-        case ITEM_CONTAINER_T1_PACKED:
-            return 'Container'
-        case ITEM_CONTAINER_T2_PACKED:
-            return 'Container'
-        default:
-            return 'Entity'
-    }
+    const template = getTemplateMeta(itemId)
+    if (!template) return 'Entity'
+    if (template.displayLabel) return template.displayLabel
+    return getKindMeta(template.kind)?.defaultLabel || 'Entity'
+}
+
+const MODULE_DISPLAY_NAME_BY_TYPE: Partial<Record<ModuleType, string>> = {
+    engine: 'Engine',
+    generator: 'Power Core',
+    gatherer: 'Limpet Bay',
+    loader: 'Shuttle Bay',
+    crafter: 'Fabricator',
+    storage: 'Cargo Hold',
+    hauler: 'Tractor Beam',
+    warp: 'Warp Drive',
+    battery: 'Battery Bank',
+    launcher: 'Drive Coil',
+    builder: 'Assembly Arm',
 }
 
 export function moduleDisplayName(itemId: number): string {
-    switch (itemId) {
-        case ITEM_ENGINE_T1:
-            return 'Engine'
-        case ITEM_GENERATOR_T1:
-            return 'Generator'
-        case ITEM_GATHERER_T1:
-            return 'Gatherer'
-        case ITEM_LOADER_T1:
-            return 'Loader'
-        case ITEM_CRAFTER_T1:
-            return 'Crafter'
-        case ITEM_STORAGE_T1:
-            return 'Storage'
-        case ITEM_HAULER_T1:
-            return 'Hauler'
-        case ITEM_WARP_T1:
-            return 'Warp'
-        default:
-            return 'Module'
-    }
+    const item = tryGetItem(itemId)
+    if (item?.type !== 'module' || !item.moduleType) return 'Module'
+    return MODULE_DISPLAY_NAME_BY_TYPE[item.moduleType] ?? 'Module'
 }
 
 export function formatModuleLine(slot: number, itemId: number, stats: bigint): string {
@@ -115,60 +219,83 @@ export function formatModuleLine(slot: number, itemId: number, stats: bigint): s
 
     switch (subtype) {
         case MODULE_ENGINE: {
-            const vol = decodeStat(stats, 0)
-            const thm = decodeStat(stats, 1)
-            out += `  Thrust ${computeEngineThrust(vol)}  Drain ${computeEngineDrain(thm)}`
+            const vol = computeEffectiveModuleStat(decodeStat(stats, 0))
+            const thm = computeEffectiveModuleStat(decodeStat(stats, 1))
+            const tier = getItem(itemId).tier
+            out += `  Thrust ${computeEngineThrust(vol, tier)}  Drain ${computeEngineDrain(thm)}`
             break
         }
         case MODULE_GENERATOR: {
-            const res = decodeStat(stats, 0)
-            const ref = decodeStat(stats, 1)
-            out += `  Capacity ${computeGeneratorCap(res)}  Recharge ${computeGeneratorRech(ref)}`
+            const res = computeEffectiveModuleStat(decodeStat(stats, 0))
+            const ref = computeEffectiveModuleStat(decodeStat(stats, 1))
+            const tier = getItem(itemId).tier
+            out += `  Capacity ${toWholeEnergy(computeGeneratorCap(res, tier))}  Recharge ${toWholeEnergy(
+                computeGeneratorRech(ref, tier)
+            )}`
             break
         }
         case MODULE_GATHERER: {
             const str = decodeStat(stats, 0)
             const tol = decodeStat(stats, 1)
-            const con = decodeStat(stats, 3)
-            const ref = decodeStat(stats, 4)
+            const con = decodeStat(stats, 2)
             const tier = getItem(itemId).tier
-            out += `  Yield ${computeGathererYield(str)}  Depth ${computeGathererDepth(
+            out += `  Yield ${computeGathererYield(str, tier)}  Depth ${computeGathererDepth(
                 tol,
                 tier
-            )}  Speed ${computeGathererSpeed(ref)}  Drain ${computeGathererDrain(con)}`
+            )}  Drain ${toWholeEnergy(computeGathererDrain(con))}`
             break
         }
         case MODULE_LOADER: {
             const fin = decodeStat(stats, 0)
             const pla = decodeStat(stats, 1)
-            out += `  Mass ${computeLoaderMass(fin)}  Thrust ${computeLoaderThrust(pla)}`
+            const tier = getItem(itemId).tier
+            out += `  Mass ${formatMassTonnes(computeLoaderMass(fin))}  Thrust ${computeLoaderThrust(pla, tier)}`
             break
         }
         case MODULE_CRAFTER: {
             const rea = decodeStat(stats, 0)
-            const com = decodeStat(stats, 1)
-            out += `  Speed ${computeCrafterSpeed(rea)}  Drain ${computeCrafterDrain(com)}`
+            const con = decodeStat(stats, 1)
+            const tier = getItem(itemId).tier
+            out += `  Speed ${computeCrafterSpeed(rea, tier)}  Drain ${toWholeEnergy(computeCrafterDrain(con))}`
+            break
+        }
+        case MODULE_BUILDER: {
+            const res = decodeStat(stats, 0)
+            const fin = decodeStat(stats, 1)
+            const tier = getItem(itemId).tier
+            out += `  Speed ${computeBuilderSpeed(res, tier)}  Drain ${toWholeEnergy(computeBuilderDrain(fin))}`
             break
         }
         case MODULE_STORAGE: {
             const str = decodeStat(stats, 0)
-            const fin = decodeStat(stats, 2)
-            const sat = decodeStat(stats, 3)
-            const sum = str + fin + sat
-            const pct = 10 + idiv(sum * 10, 2997)
-            out += `  +${pct}% capacity`
+            const den = decodeStat(stats, 1)
+            const hrd = decodeStat(stats, 2)
+            const coh = decodeStat(stats, 3)
+            const tier = getItem(itemId).tier
+            out += `  Cargo Capacity ${formatMassTonnes(computeCargoBayCapacity(str, den, hrd, tier))}  Drain ${toWholeEnergy(computeCargoBayDrain(coh, tier))}`
             break
         }
         case MODULE_HAULER: {
-            const fin = decodeStat(stats, 0)
-            const con = decodeStat(stats, 1)
-            const com = decodeStat(stats, 2)
-            out += `  Capacity ${computeHaulerCapacity(fin)}  Efficiency ${computeHaulerEfficiency(con)}  Drain ${computeHaulerDrain(com)}`
+            const res = decodeStat(stats, 0)
+            const pla = decodeStat(stats, 1)
+            const con = decodeStat(stats, 2)
+            const tier = getItem(itemId).tier
+            out += `  Capacity ${computeHaulerCapacity(res, tier)}  Efficiency ${computeHaulerEfficiency(pla)}  Drain ${toWholeEnergy(computeHaulerDrain(con, tier))}`
             break
         }
         case MODULE_WARP: {
             const stat = decodeStat(stats, 0)
-            out += `  Range ${computeWarpRange(stat)}`
+            const tier = getItem(itemId).tier
+            out += `  Range ${computeWarpRange(stat, tier)}`
+            break
+        }
+        case MODULE_BATTERY: {
+            const vol = decodeStat(stats, 0)
+            const thm = decodeStat(stats, 1)
+            const pla = decodeStat(stats, 2)
+            const ins = decodeStat(stats, 3)
+            const tier = getItem(itemId).tier
+            out += `  Energy Capacity ${toWholeEnergy(computeBatteryBankCapacity(vol, thm, pla, ins, tier))}`
             break
         }
     }
@@ -181,18 +308,13 @@ export function buildEntityDescription(
     moduleItems: number[],
     moduleStats: bigint[]
 ): string {
-    const hullMass = computeBaseHullmass(hullStats)
-    let baseCapacity = 0
-    if (itemId === ITEM_SHIP_T1_PACKED) {
-        baseCapacity = computeBaseCapacityShip(hullStats)
-    } else if (itemId === ITEM_WAREHOUSE_T1_PACKED) {
-        baseCapacity = computeBaseCapacityWarehouse(hullStats)
-    }
+    const hullMass = computeBaseHullmass(itemId, hullStats)
+    const baseCapacity = computeBaseCapacityForEntity(itemId, hullStats)
 
     let out = entityDisplayName(itemId)
-    out += ` - Hull ${hullMass} mass`
+    out += ` - Hull ${formatMassTonnes(hullMass)}`
     if (baseCapacity > 0) {
-        out += ` * ${baseCapacity} capacity`
+        out += ` * ${formatMassTonnes(baseCapacity)} capacity`
     }
     out += '\n\n'
 

package/src/nft/index.ts

@@ -1,2 +1,5 @@
 export * from './deserializers'
 export * from './description'
+export * from './atomicdata'
+export * from './atomicassets'
+export * from './buildImmutableData'