@shipload/sdk 1.0.0-next.51 → 1.0.0-next.52

package/src/nft/description.ts

@@ -1,5 +1,6 @@
 import {
     getModuleCapabilityType,
+    MODULE_BUILDER,
     MODULE_CRAFTER,
     MODULE_ENGINE,
     MODULE_GATHERER,
@@ -13,6 +14,7 @@ import {
 import {
     ITEM_CONTAINER_T1_PACKED,
     ITEM_CONTAINER_T2_PACKED,
+    ITEM_BUILDER_T1,
     ITEM_CRAFTER_T1,
     ITEM_ENGINE_T1,
     ITEM_EXTRACTOR_T1_PACKED,
@@ -26,28 +28,56 @@ import {
     ITEM_BATTERY_T1,
     ITEM_LAUNCHER_T1,
     ITEM_LOADER_T1,
+    ITEM_PROSPECTOR_T1_PACKED,
     ITEM_PROSPECTOR_T2_PACKED,
+    ITEM_ROUSTABOUT_T1_PACKED,
     ITEM_SHIP_T1_PACKED,
     ITEM_STORAGE_T1,
+    ITEM_TENDER_T1_PACKED,
+    ITEM_TUG_T1_PACKED,
+    ITEM_PORTER_T1_PACKED,
+    ITEM_WRANGLER_T1_PACKED,
+    ITEM_DREDGER_T1_PACKED,
     ITEM_WAREHOUSE_T1_PACKED,
     ITEM_WARP_T1,
 } from '../data/item-ids'
 import {decodeStat} from '../derivation/crafting'
 import {gathererDepthForTier} from '../derivation/capabilities'
 import {getItem} from '../data/catalog'
+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)
+}
+
+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 100000 - 75 * density
+    return Math.floor((getBaseHullmassFor(itemId) * (2000 - density)) / 2000)
 }
 
 export function computeBaseCapacityShip(stats: bigint): number {
-    const s = decodeStat(stats, 0) + decodeStat(stats, 2)
-    return Math.floor(5_000_000 * 6 ** (s / 1998))
+    return Math.floor(5_000_000 * 6 ** (sumPackedShipChannels(stats) / 4995))
 }
 
 export function computeBaseCapacityContainer(stats: bigint): number {
@@ -62,49 +92,75 @@ export function computeBaseCapacityWarehouse(stats: bigint): number {
 
 export const computeEngineThrust = (vol: number): number => 400 + idiv(vol * 3, 4)
 export const computeEngineDrain = (thm: number): number => 2 * Math.max(30, 50 - idiv(thm, 70))
-export const ENGINE_DRAIN_BASE = 118
+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 num = ENGINE_DRAIN_BASE * ENGINE_DRAIN_REF_THRUST * computeEngineDrain(avgThm)
-    const den = totalThrust * computeEngineDrain(ENGINE_DRAIN_REF_THM)
-    return idiv(num, den)
+    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): number => 1300 + idiv(com, 2)
-export const computeGeneratorRech = (fin: number): number => 2 * (1 + idiv(fin * 3, 1000))
+export const computeGeneratorCap = (com: number): number => 1_300_000 + com * 500
+export const computeGeneratorRech = (fin: number): number => 2000 + fin * 6
 export const computeGathererYield = (str: number): number => 200 + str
 export const computeGathererDrain = (con: number): number =>
-    2 * 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 computeLoaderMass = (ins: number): number => Math.max(200, 2000 - ins * 2)
 export const computeLoaderThrust = (pla: number): number => 1 + idiv(pla * pla, 10000)
 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 computeCrafterDrain = (fin: number): number =>
+    Math.max(5000, 30000 - idiv(fin * 1000, 33))
+export const computeBuilderSpeed = (coh: number): number => 100 + idiv(coh * 4, 5)
+export const computeBuilderDrain = (tol: number): number =>
+    Math.max(5000, 30000 - idiv(tol * 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 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): number => 100 + stat * 3
 export const computeCargoBayCapacity = (
     strength: number,
     density: number,
-    hardness: number,
-    cohesion: number
-): number => 10_000_000 + idiv((strength + density + hardness + cohesion) * 50_000_000, 3996)
+    hardness: number
+): number => 10_000_000 + idiv((strength + density + hardness) * 50_000_000, 2997)
 export const computeBatteryBankCapacity = (
     volatility: number,
     thermal: number,
     plasticity: number,
     insulation: number
-): number => 2_500 + idiv((volatility + thermal + plasticity + insulation) * 7_500, 3996)
+): number => 2_500_000 + idiv((volatility + thermal + plasticity + insulation) * 7_500_000, 3996)
 
 export function entityDisplayName(itemId: number): string {
     switch (itemId) {
         case ITEM_SHIP_T1_PACKED:
+            return 'Ship'
+        case ITEM_ROUSTABOUT_T1_PACKED:
             return 'Roustabout'
+        case ITEM_PROSPECTOR_T1_PACKED:
+            return 'Prospector'
+        case ITEM_TENDER_T1_PACKED:
+            return 'Tender'
+        case ITEM_TUG_T1_PACKED:
+            return 'Tug'
+        case ITEM_PORTER_T1_PACKED:
+            return 'Porter'
+        case ITEM_WRANGLER_T1_PACKED:
+            return 'Wrangler'
+        case ITEM_DREDGER_T1_PACKED:
+            return 'Dredger'
         case ITEM_WAREHOUSE_T1_PACKED:
             return 'Warehouse'
         case ITEM_EXTRACTOR_T1_PACKED:
@@ -118,7 +174,7 @@ export function entityDisplayName(itemId: number): string {
         case ITEM_PROSPECTOR_T2_PACKED:
             return 'Prospector'
         case ITEM_HAULER_SHIP_T2_PACKED:
-            return 'Hauler'
+            return 'Tug'
         default:
             return 'Entity'
     }
@@ -137,6 +193,8 @@ export function moduleDisplayName(itemId: number): string {
             return 'Shuttle Bay'
         case ITEM_CRAFTER_T1:
             return 'Fabricator'
+        case ITEM_BUILDER_T1:
+            return 'Assembly Arm'
         case ITEM_STORAGE_T1:
             return 'Cargo Hold'
         case ITEM_HAULER_T1:
@@ -165,15 +223,17 @@ 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)
+            const vol = computeEffectiveModuleStat(decodeStat(stats, 0))
+            const thm = computeEffectiveModuleStat(decodeStat(stats, 1))
             out += `  Thrust ${computeEngineThrust(vol)}  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))
+            out += `  Capacity ${toWholeEnergy(computeGeneratorCap(res))}  Recharge ${toWholeEnergy(
+                computeGeneratorRech(ref)
+            )}`
             break
         }
         case MODULE_GATHERER: {
@@ -184,7 +244,7 @@ export function formatModuleLine(slot: number, itemId: number, stats: bigint): s
             out += `  Yield ${computeGathererYield(str)}  Depth ${computeGathererDepth(
                 tol,
                 tier
-            )}  Drain ${computeGathererDrain(con)}`
+            )}  Drain ${toWholeEnergy(computeGathererDrain(con))}`
             break
         }
         case MODULE_LOADER: {
@@ -196,23 +256,30 @@ export function formatModuleLine(slot: number, itemId: number, stats: bigint): s
         case MODULE_CRAFTER: {
             const rea = decodeStat(stats, 0)
             const con = decodeStat(stats, 1)
-            out += `  Speed ${computeCrafterSpeed(rea)}  Drain ${computeCrafterDrain(con)}`
+            out += `  Speed ${computeCrafterSpeed(rea)}  Drain ${toWholeEnergy(computeCrafterDrain(con))}`
+            break
+        }
+        case MODULE_BUILDER: {
+            const coh = decodeStat(stats, 0)
+            const tol = decodeStat(stats, 1)
+            out += `  Speed ${computeBuilderSpeed(coh)}  Drain ${toWholeEnergy(computeBuilderDrain(tol))}`
             break
         }
         case MODULE_STORAGE: {
             const str = decodeStat(stats, 0)
             const den = decodeStat(stats, 1)
             const hrd = decodeStat(stats, 2)
-            const com = decodeStat(stats, 3)
-            out += `  Cargo Capacity ${computeCargoBayCapacity(str, den, hrd, com)}`
+            const coh = decodeStat(stats, 3)
+            const tier = getItem(itemId).tier
+            out += `  Cargo Capacity ${computeCargoBayCapacity(str, den, hrd)}  Drain ${toWholeEnergy(computeCargoBayDrain(coh, tier))}`
             break
         }
         case MODULE_HAULER: {
             const res = decodeStat(stats, 0)
             const pla = decodeStat(stats, 1)
-            const ref = decodeStat(stats, 2)
+            const con = decodeStat(stats, 2)
             const tier = getItem(itemId).tier
-            out += `  Capacity ${computeHaulerCapacity(res, tier)}  Efficiency ${computeHaulerEfficiency(pla)}  Drain ${computeHaulerDrain(ref)}`
+            out += `  Capacity ${computeHaulerCapacity(res, tier)}  Efficiency ${computeHaulerEfficiency(pla)}  Drain ${toWholeEnergy(computeHaulerDrain(con, tier))}`
             break
         }
         case MODULE_WARP: {
@@ -225,7 +292,7 @@ export function formatModuleLine(slot: number, itemId: number, stats: bigint): s
             const thm = decodeStat(stats, 1)
             const pla = decodeStat(stats, 2)
             const ins = decodeStat(stats, 3)
-            out += `  Energy Capacity ${computeBatteryBankCapacity(vol, thm, pla, ins)}`
+            out += `  Energy Capacity ${toWholeEnergy(computeBatteryBankCapacity(vol, thm, pla, ins))}`
             break
         }
     }
@@ -238,13 +305,9 @@ export function buildEntityDescription(
     moduleItems: number[],
     moduleStats: bigint[]
 ): string {
-    const hullMass = computeBaseHullmass(hullStats)
+    const hullMass = computeBaseHullmass(itemId, hullStats)
     let baseCapacity = 0
-    if (
-        itemId === ITEM_SHIP_T1_PACKED ||
-        itemId === ITEM_PROSPECTOR_T2_PACKED ||
-        itemId === ITEM_HAULER_SHIP_T2_PACKED
-    ) {
+    if (isShipHull(itemId)) {
         baseCapacity = computeBaseCapacityShip(hullStats)
     } else if (itemId === ITEM_WAREHOUSE_T1_PACKED) {
         baseCapacity = computeBaseCapacityWarehouse(hullStats)

package/src/planner/planner.test.ts

@@ -58,7 +58,7 @@ function entity(overrides: EntityOverrides = {}): GatherPlanEntity {
         gatherer_lanes: overrides.gatherer_lanes ?? [],
         loader_lanes: overrides.loader_lanes ?? [],
         generator: overrides.generator,
-        energy: overrides.energy !== undefined ? UInt16.from(overrides.energy) : undefined,
+        energy: overrides.energy !== undefined ? UInt32.from(overrides.energy) : undefined,
         lanes: overrides.lanes ?? [],
         coordinates: ServerContract.Types.coordinates.from({x: 0, y: 0}),
         cargo: [],
@@ -118,27 +118,30 @@ describe('cost helpers', () => {
     const RICHNESS = 500
 
     test('gatherEnergyCost is 0 for non-positive quantity and positive otherwise', () => {
-        const lane = gathererLane(0, 700, 1250, 5000)
+        const lane = gathererLane(0, 700, 1_250_000, 5000)
         expect(gatherEnergyCost(lane, 0, STRATUM, ITEM_MASS, RICHNESS)).toBe(0)
         expect(gatherEnergyCost(lane, 100, STRATUM, ITEM_MASS, RICHNESS)).toBeGreaterThan(0)
     })
 
     test('splitCost across two lanes is monotonic non-decreasing in quantity', () => {
-        const reaching = [gathererLane(0, 700, 1250, 5000), gathererLane(1, 700, 1250, 5000)]
+        const reaching = [
+            gathererLane(0, 700, 1_250_000, 5000),
+            gathererLane(1, 700, 1_250_000, 5000),
+        ]
         const c100 = splitCost(reaching, 100, STRATUM, ITEM_MASS, RICHNESS)
         const c200 = splitCost(reaching, 200, STRATUM, ITEM_MASS, RICHNESS)
         expect(c200).toBeGreaterThanOrEqual(c100)
     })
 
     test('maxQtyForCharge returns hi when the whole batch fits the charge', () => {
-        const reaching = [gathererLane(0, 700, 1250, 5000)]
+        const reaching = [gathererLane(0, 700, 1_250_000, 5000)]
         // capacity huge → the full 500 fits
         expect(maxQtyForCharge(reaching, 500, 1_000_000, STRATUM, ITEM_MASS, RICHNESS)).toBe(500)
     })
 
     test('maxQtyForCharge finds the boundary: result fits, result+1 does not', () => {
-        const reaching = [gathererLane(0, 700, 1250, 5000)]
-        const capacity = 40
+        const reaching = [gathererLane(0, 700, 1_250_000, 5000)]
+        const capacity = 40_000
         const q = maxQtyForCharge(reaching, 100_000, capacity, STRATUM, ITEM_MASS, RICHNESS)
         expect(splitCost(reaching, q, STRATUM, ITEM_MASS, RICHNESS)).toBeLessThanOrEqual(capacity)
         expect(splitCost(reaching, q + 1, STRATUM, ITEM_MASS, RICHNESS)).toBeGreaterThan(capacity)
@@ -157,9 +160,9 @@ describe('buildGatherPlan', () => {
 
     test('single cycle when the target fits one charge and energy is full', () => {
         const e = entity({
-            gatherer_lanes: [gathererLane(0, 700, 1250, 5000)],
-            generator: energyStats(1200, 2),
-            energy: 1200,
+            gatherer_lanes: [gathererLane(0, 700, 1_250_000, 5000)],
+            generator: energyStats(1_200_000, 2000),
+            energy: 1_200_000,
         })
         const plan = buildGatherPlan(e, STRATUM, {quantity: 100}, OPTS)
         expect(plan.cycleCount).toBe(1)
@@ -172,9 +175,12 @@ describe('buildGatherPlan', () => {
 
     test('two limpets split one charge proportional to yield, finish within 1s of each other', () => {
         const e = entity({
-            gatherer_lanes: [gathererLane(0, 200, 500, 5000), gathererLane(1, 400, 500, 5000)],
-            generator: energyStats(60_000, 2),
-            energy: 60_000,
+            gatherer_lanes: [
+                gathererLane(0, 200, 500_000, 5000),
+                gathererLane(1, 400, 500_000, 5000),
+            ],
+            generator: energyStats(60_000_000, 2000),
+            energy: 60_000_000,
         })
         const plan = buildGatherPlan(e, STRATUM, {quantity: 60}, OPTS)
         expect(plan.cycleCount).toBe(1)
@@ -185,9 +191,9 @@ describe('buildGatherPlan', () => {
     })
 
     test('multi-cycle: fills beyond one charge; totalOre equals fill target; each cycle fits the charge', () => {
-        const CAP = 40
+        const CAP = 40_000
         const e = entity({
-            gatherer_lanes: [gathererLane(0, 700, 1250, 5000)],
+            gatherer_lanes: [gathererLane(0, 700, 1_250_000, 5000)],
             generator: energyStats(CAP, 2),
             energy: CAP,
         })
@@ -214,9 +220,9 @@ describe('buildGatherPlan', () => {
 
     test('cap reasons: hold binds, reserve binds, requested binds', () => {
         const e = entity({
-            gatherer_lanes: [gathererLane(0, 700, 1250, 5000)],
-            generator: energyStats(60_000, 2),
-            energy: 60_000,
+            gatherer_lanes: [gathererLane(0, 700, 1_250_000, 5000)],
+            generator: energyStats(60_000_000, 2000),
+            energy: 60_000_000,
         })
         expect(
             buildGatherPlan(e, STRATUM, 'max', {...OPTS, holdRoom: 300, reserveRemaining: 9999}).cap
@@ -228,9 +234,9 @@ describe('buildGatherPlan', () => {
     })
 
     test('total ETA sums per-cycle recharge + gather seconds', () => {
-        const CAP = 40
+        const CAP = 40_000
         const e = entity({
-            gatherer_lanes: [gathererLane(0, 700, 1250, 5000)],
+            gatherer_lanes: [gathererLane(0, 700, 1_250_000, 5000)],
             generator: energyStats(CAP, 2),
             energy: CAP,
         })
@@ -242,11 +248,11 @@ describe('buildGatherPlan', () => {
     test('excludes limpets that cannot reach the stratum and warns', () => {
         const e = entity({
             gatherer_lanes: [
-                gathererLane(0, 700, 1250, 5000), // reaches 100
-                gathererLane(1, 700, 1250, 50), // does not reach 100
+                gathererLane(0, 700, 1_250_000, 5000), // reaches 100
+                gathererLane(1, 700, 1_250_000, 50), // does not reach 100
             ],
-            generator: energyStats(60_000, 2),
-            energy: 60_000,
+            generator: energyStats(60_000_000, 2000),
+            energy: 60_000_000,
         })
         const plan = buildGatherPlan(e, STRATUM, {quantity: 100}, OPTS)
         expect(plan.cycles[0].limpets).toHaveLength(1)
@@ -256,9 +262,12 @@ describe('buildGatherPlan', () => {
 
     test('reports structured limpet reach counts (all reaching)', () => {
         const e = entity({
-            gatherer_lanes: [gathererLane(0, 700, 1250, 5000), gathererLane(1, 700, 1250, 5000)],
-            generator: energyStats(60_000, 2),
-            energy: 60_000,
+            gatherer_lanes: [
+                gathererLane(0, 700, 1_250_000, 5000),
+                gathererLane(1, 700, 1_250_000, 5000),
+            ],
+            generator: energyStats(60_000_000, 2000),
+            energy: 60_000_000,
         })
         const plan = buildGatherPlan(e, STRATUM, {quantity: 50}, OPTS)
         expect(plan.totalLimpets).toBe(2)
@@ -268,11 +277,11 @@ describe('buildGatherPlan', () => {
     test('reachingCount excludes limpets that cannot reach the stratum', () => {
         const e = entity({
             gatherer_lanes: [
-                gathererLane(0, 700, 1250, 5000), // reaches 100
-                gathererLane(1, 700, 1250, 50), // does not reach 100
+                gathererLane(0, 700, 1_250_000, 5000), // reaches 100
+                gathererLane(1, 700, 1_250_000, 50), // does not reach 100
             ],
-            generator: energyStats(60_000, 2),
-            energy: 60_000,
+            generator: energyStats(60_000_000, 2000),
+            energy: 60_000_000,
         })
         const plan = buildGatherPlan(e, STRATUM, {quantity: 50}, OPTS)
         expect(plan.totalLimpets).toBe(2)
@@ -280,9 +289,9 @@ describe('buildGatherPlan', () => {
     })
 
     test('single-limpet ship still fills across cycles', () => {
-        const CAP = 40
+        const CAP = 40_000
         const e = entity({
-            gatherer_lanes: [gathererLane(0, 700, 1250, 5000)],
+            gatherer_lanes: [gathererLane(0, 700, 1_250_000, 5000)],
             generator: energyStats(CAP, 2),
             energy: CAP,
         })
@@ -293,18 +302,18 @@ describe('buildGatherPlan', () => {
 
     test('throws when no gatherer reaches the stratum', () => {
         const e = entity({
-            gatherer_lanes: [gathererLane(0, 700, 1250, 50)],
-            generator: energyStats(1200, 2),
-            energy: 1200,
+            gatherer_lanes: [gathererLane(0, 700, 1_250_000, 50)],
+            generator: energyStats(1_200_000, 2000),
+            energy: 1_200_000,
         })
         expect(() => buildGatherPlan(e, STRATUM, 'max', OPTS)).toThrow('no gatherer reaches')
     })
 
     test('zero fill target yields an empty plan (no cycles)', () => {
         const e = entity({
-            gatherer_lanes: [gathererLane(0, 700, 1250, 5000)],
-            generator: energyStats(1200, 2),
-            energy: 1200,
+            gatherer_lanes: [gathererLane(0, 700, 1_250_000, 5000)],
+            generator: energyStats(1_200_000, 2000),
+            energy: 1_200_000,
         })
         const plan = buildGatherPlan(e, STRATUM, 'max', {...OPTS, holdRoom: 0})
         expect(plan.cycleCount).toBe(0)
@@ -314,9 +323,9 @@ describe('buildGatherPlan', () => {
 
     test('first cycle skips recharge when current energy already covers the small batch', () => {
         const e = entity({
-            gatherer_lanes: [gathererLane(0, 700, 1250, 5000)],
-            generator: energyStats(60_000, 2),
-            energy: 60_000, // full
+            gatherer_lanes: [gathererLane(0, 700, 1_250_000, 5000)],
+            generator: energyStats(60_000_000, 2000),
+            energy: 60_000_000, // full
         })
         const plan = buildGatherPlan(e, STRATUM, {quantity: 50}, OPTS)
         expect(plan.cycles[0].rechargeBefore).toBe(false)

package/src/resolution/resolve-item.test.ts

@@ -42,7 +42,7 @@ test('resolveItem resolves the station hub with hullmass and zero cargo capacity
     const resolved = resolveItem(UInt16.from(ITEM_HUB_T1_PACKED), stats)
     const hull = resolved.attributes?.find((g) => g.capability === 'Hull')
     expect(hull?.attributes.find((a) => a.label === 'Mass')?.value).toBe(
-        computeBaseHullmass({density: 100})
+        computeBaseHullmass(ITEM_HUB_T1_PACKED, {density: 100})
     )
     expect(hull?.attributes.find((a) => a.label === 'Capacity')?.value).toBe(0)
 })

package/src/resolution/resolve-item.ts

@@ -2,6 +2,7 @@ import {UInt16, UInt64} from '@wharfkit/antelope'
 import type {UInt16Type, UInt64Type} from '@wharfkit/antelope'
 import type {ResourceCategory} from '../types'
 import {getItem, getModules} from '../data/catalog'
+import {ENTITY_SHIP, getPackedEntityType} from '../data/kind-registry'
 import {getEntityLayout} from '../data/recipes-runtime'
 import {entityMetadata, itemMetadata} from '../data/metadata'
 import {
@@ -31,6 +32,7 @@ import {
     computeStorageCapabilities,
 } from '../derivation/capabilities'
 import {applySlotMultiplierUint32} from '../entities/slot-multiplier'
+import {toWholeEnergy} from '../nft/description'
 import {categoryColors, componentIcon, itemAbbreviations, moduleIcon} from '../data/colors'
 import type {ServerContract} from '../contracts'
 
@@ -171,8 +173,8 @@ function computeCapabilityGroup(
             return {
                 capability: 'Generator',
                 attributes: [
-                    {label: 'Capacity', value: caps.capacity},
-                    {label: 'Recharge', value: caps.recharge},
+                    {label: 'Capacity', value: toWholeEnergy(caps.capacity)},
+                    {label: 'Recharge', value: toWholeEnergy(caps.recharge)},
                 ],
             }
         }
@@ -182,7 +184,7 @@ function computeCapabilityGroup(
                 capability: 'Gatherer',
                 attributes: [
                     {label: 'Yield', value: caps.yield},
-                    {label: 'Drain', value: caps.drain},
+                    {label: 'Drain', value: toWholeEnergy(caps.drain)},
                     {label: 'Depth', value: caps.depth},
                 ],
             }
@@ -204,7 +206,7 @@ function computeCapabilityGroup(
                 capability: 'Crafting',
                 attributes: [
                     {label: 'Speed', value: caps.speed},
-                    {label: 'Drain', value: caps.drain},
+                    {label: 'Drain', value: toWholeEnergy(caps.drain)},
                 ],
             }
         }
@@ -215,12 +217,12 @@ function computeCapabilityGroup(
                 attributes: [
                     {label: 'Capacity', value: caps.capacity},
                     {label: 'Efficiency', value: caps.efficiency},
-                    {label: 'Drain', value: caps.drain},
+                    {label: 'Drain', value: toWholeEnergy(caps.drain)},
                 ],
             }
         }
         case MODULE_STORAGE: {
-            const caps = computeStorageCapabilities(stats)
+            const caps = computeStorageCapabilities(stats, tier)
             return {
                 capability: 'Storage',
                 attributes: [
@@ -228,6 +230,7 @@ function computeCapabilityGroup(
                         label: 'Cargo Capacity',
                         value: applySlotMultiplierUint32(caps.capacity, outputPct),
                     },
+                    {label: 'Drain', value: toWholeEnergy(caps.drain)},
                 ],
             }
         }
@@ -238,7 +241,7 @@ function computeCapabilityGroup(
                 attributes: [
                     {
                         label: 'Energy Capacity',
-                        value: applySlotMultiplierUint32(caps.capacity, outputPct),
+                        value: toWholeEnergy(applySlotMultiplierUint32(caps.capacity, outputPct)),
                     },
                 ],
             }
@@ -282,14 +285,26 @@ function resolveModule(id: number, stats?: UInt64Type): ResolvedItem {
 
 function hullCapsForEntity(
     itemId: number,
-    decoded: Record<string, number>
+    decoded: Record<string, number>,
+    packedStats: bigint
 ): {
     hullmass: number
     capacity: number
 } {
+    // A ship hull consumes all five positional packed channels. This is separate
+    // from the recipe-facing stat labels, which remain historical for Ship T1.
+    const hullStats = getPackedEntityType(itemId)?.equals(ENTITY_SHIP)
+        ? {
+              strength: decodeStat(packedStats, 0),
+              hardness: decodeStat(packedStats, 1),
+              plasticity: decodeStat(packedStats, 2),
+              volatility: decodeStat(packedStats, 3),
+              conductivity: decodeStat(packedStats, 4),
+          }
+        : decoded
     return {
-        hullmass: computeBaseHullmass(decoded),
-        capacity: computeBaseCapacity(itemId, decoded),
+        hullmass: computeBaseHullmass(itemId, hullStats),
+        capacity: computeBaseCapacity(itemId, hullStats),
     }
 }
 
@@ -309,7 +324,7 @@ function resolveEntity(
         if (decoded.strength === undefined) decoded.strength = decodeStat(bigStats, 0)
         if (decoded.density === undefined) decoded.density = decodeStat(bigStats, 1)
         if (decoded.hardness === undefined) decoded.hardness = decodeStat(bigStats, 2)
-        const hullCaps = hullCapsForEntity(id, decoded)
+        const hullCaps = hullCapsForEntity(id, decoded, bigStats)
         attributes = [
             {
                 capability: 'Hull',

package/src/scheduling/availability.ts

@@ -23,14 +23,15 @@ export function taskCargoEffect(task: Task): CargoEffect {
         case TaskType.UNLOAD:
             return {added: [], removed: task.cargo}
         case TaskType.GATHER:
-            return task.entitytarget ? {added: [], removed: []} : {added: task.cargo, removed: []}
+            return task.couplings.length > 0
+                ? {added: [], removed: []}
+                : {added: task.cargo, removed: []}
         case TaskType.CRAFT:
             if (task.cargo.length === 0) return {added: [], removed: []}
-            return {added: [task.cargo[task.cargo.length - 1]], removed: task.cargo.slice(0, -1)}
-        case TaskType.DEPLOY:
-            return task.cargo.length > 0
-                ? {added: [], removed: [task.cargo[0]]}
-                : {added: [], removed: []}
+            return {
+                added: task.couplings.length === 0 ? [task.cargo[task.cargo.length - 1]] : [],
+                removed: task.cargo.slice(0, -1),
+            }
         default:
             return {added: [], removed: []}
     }