@shipload/sdk 1.0.0-next.35 → 1.0.0-next.37

package/src/coordinates/memo.ts

@@ -0,0 +1,20 @@
+import type {Checksum256Type} from '@wharfkit/antelope'
+import {Checksum256} from '@wharfkit/antelope'
+import {type CoordinateAddress, encodeAddress} from './address'
+
+const cache = new Map<string, CoordinateAddress>()
+const CACHE_MAX = 4096
+
+export function encodeAddressMemo(seed: Checksum256Type, x: number, y: number): CoordinateAddress {
+    const key = `${Checksum256.from(seed).toString()}:${x},${y}`
+    let hit = cache.get(key)
+    if (!hit) {
+        hit = encodeAddress(seed, x, y)
+        if (cache.size >= CACHE_MAX) {
+            const oldest = cache.keys().next().value
+            if (oldest !== undefined) cache.delete(oldest)
+        }
+        cache.set(key, hit)
+    }
+    return hit
+}

package/src/data/capability-formulas.ts

@@ -23,7 +23,6 @@ const ENTITY_HULL_SLOTS: Record<number, SlotConsumer> = {
     0: {capability: 'Storage', attribute: 'capacity'},
     1: {capability: 'Hull', attribute: 'mass'},
     2: {capability: 'Storage', attribute: 'capacity'},
-    3: {capability: 'Storage', attribute: 'capacity'},
 }
 
 export const SLOT_FORMULAS: Record<SlotConsumerKind, Record<number, SlotConsumer>> = {

package/src/data/entities.json

@@ -58,11 +58,11 @@
     "slots": [
       {
         "type": "generator",
-        "outputPct": 100
+        "outputPct": 200
       },
       {
         "type": "gatherer",
-        "outputPct": 100
+        "outputPct": 200
       }
     ]
   },
@@ -71,11 +71,11 @@
     "slots": [
       {
         "type": "generator",
-        "outputPct": 100
+        "outputPct": 200
       },
       {
         "type": "crafter",
-        "outputPct": 100
+        "outputPct": 200
       }
     ]
   },

package/src/data/items.json

@@ -474,31 +474,31 @@
   },
   {
     "id": 10200,
-    "mass": 1300000,
+    "mass": 1900000,
     "type": "entity",
     "tier": 1
   },
   {
     "id": 10201,
-    "mass": 1900000,
+    "mass": 2400000,
     "type": "entity",
     "tier": 1
   },
   {
     "id": 10202,
-    "mass": 4800000,
+    "mass": 3200000,
     "type": "entity",
     "tier": 1
   },
   {
     "id": 10203,
-    "mass": 3700000,
+    "mass": 1900000,
     "type": "entity",
     "tier": 1
   },
   {
     "id": 10204,
-    "mass": 4600000,
+    "mass": 1900000,
     "type": "entity",
     "tier": 1
   },

package/src/data/recipes.json

@@ -651,15 +651,15 @@
   },
   {
     "outputItemId": 10200,
-    "outputMass": 1300000,
+    "outputMass": 1900000,
     "inputs": [
       {
         "itemId": 10001,
         "quantity": 600
       },
       {
-        "itemId": 10002,
-        "quantity": 200
+        "itemId": 10008,
+        "quantity": 600
       }
     ],
     "statSlots": [
@@ -700,15 +700,27 @@
   },
   {
     "outputItemId": 10201,
-    "outputMass": 1900000,
+    "outputMass": 2400000,
     "inputs": [
       {
         "itemId": 10001,
-        "quantity": 800
+        "quantity": 300
       },
       {
-        "itemId": 10002,
-        "quantity": 400
+        "itemId": 10008,
+        "quantity": 300
+      },
+      {
+        "itemId": 10007,
+        "quantity": 300
+      },
+      {
+        "itemId": 10003,
+        "quantity": 300
+      },
+      {
+        "itemId": 10006,
+        "quantity": 300
       }
     ],
     "statSlots": [
@@ -729,34 +741,24 @@
         ]
       },
       {
-        "sources": [
-          {
-            "inputIndex": 1,
-            "statIndex": 0
-          }
-        ]
+        "sources": []
       },
       {
-        "sources": [
-          {
-            "inputIndex": 1,
-            "statIndex": 1
-          }
-        ]
+        "sources": []
       }
     ],
     "blendWeights": []
   },
   {
     "outputItemId": 10202,
-    "outputMass": 4800000,
+    "outputMass": 3200000,
     "inputs": [
       {
         "itemId": 10001,
-        "quantity": 2000
+        "quantity": 1000
       },
       {
-        "itemId": 10002,
+        "itemId": 10008,
         "quantity": 1000
       }
     ],
@@ -798,25 +800,20 @@
   },
   {
     "outputItemId": 10203,
-    "outputMass": 3700000,
+    "outputMass": 1900000,
     "inputs": [
       {
-        "itemId": 10001,
-        "quantity": 1500
+        "itemId": 10008,
+        "quantity": 600
       },
       {
-        "itemId": 10002,
-        "quantity": 800
+        "itemId": 10006,
+        "quantity": 600
       }
     ],
     "statSlots": [
       {
-        "sources": [
-          {
-            "inputIndex": 0,
-            "statIndex": 0
-          }
-        ]
+        "sources": []
       },
       {
         "sources": [
@@ -829,51 +826,33 @@
       {
         "sources": [
           {
-            "inputIndex": 1,
+            "inputIndex": 0,
             "statIndex": 0
           }
         ]
       },
       {
-        "sources": [
-          {
-            "inputIndex": 1,
-            "statIndex": 1
-          }
-        ]
+        "sources": []
       }
     ],
     "blendWeights": []
   },
   {
     "outputItemId": 10204,
-    "outputMass": 4600000,
+    "outputMass": 1900000,
     "inputs": [
-      {
-        "itemId": 10001,
-        "quantity": 1500
-      },
-      {
-        "itemId": 10002,
-        "quantity": 600
-      },
       {
         "itemId": 10008,
-        "quantity": 400
+        "quantity": 600
       },
       {
-        "itemId": 10009,
-        "quantity": 400
+        "itemId": 10007,
+        "quantity": 600
       }
     ],
     "statSlots": [
       {
-        "sources": [
-          {
-            "inputIndex": 0,
-            "statIndex": 0
-          }
-        ]
+        "sources": []
       },
       {
         "sources": [
@@ -886,18 +865,13 @@
       {
         "sources": [
           {
-            "inputIndex": 1,
+            "inputIndex": 0,
             "statIndex": 0
           }
         ]
       },
       {
-        "sources": [
-          {
-            "inputIndex": 1,
-            "statIndex": 1
-          }
-        ]
+        "sources": []
       }
     ],
     "blendWeights": []

package/src/derivation/capabilities.test.ts

@@ -0,0 +1,133 @@
+import {expect, test} from 'bun:test'
+import {
+    computeEntityCapabilities,
+    computeGathererCapabilities,
+    computeCrafterCapabilities,
+    computeLoaderCapabilities,
+} from './capabilities'
+import {applySlotMultiplier, U16_MAX} from '../entities/slot-multiplier'
+import {encodeStats} from './crafting'
+import {
+    ITEM_EXTRACTOR_T1_PACKED,
+    ITEM_GATHERER_T1,
+    ITEM_CRAFTER_T1,
+    ITEM_LOADER_T1,
+} from '../data/item-ids'
+import type {InstalledModule} from '../entities/slot-multiplier'
+import type {EntitySlot} from '../data/recipes-runtime'
+
+function makeGathererStats(strength: number, tolerance: number, conductivity: number): bigint {
+    return encodeStats([strength, tolerance, conductivity, 0])
+}
+
+function makeCrafterStats(reactivity: number, fineness: number): bigint {
+    return encodeStats([reactivity, fineness])
+}
+
+function makeLoaderStats(insulation: number, plasticity: number): bigint {
+    return encodeStats([insulation, plasticity])
+}
+
+test('computeEntityCapabilities emits gathererLanes alongside legacy gatherer sum', () => {
+    // Two gatherers with distinct stats in separate slots, amp=100 for both
+    const gathStats1 = makeGathererStats(300, 200, 400)
+    const gathStats2 = makeGathererStats(500, 100, 300)
+
+    const modules: InstalledModule[] = [
+        {slotIndex: 0, itemId: ITEM_GATHERER_T1, stats: gathStats1},
+        {slotIndex: 1, itemId: ITEM_GATHERER_T1, stats: gathStats2},
+    ]
+
+    const layout: EntitySlot[] = [
+        {type: 'gatherer', outputPct: 100},
+        {type: 'gatherer', outputPct: 100},
+    ]
+
+    const result = computeEntityCapabilities({}, ITEM_EXTRACTOR_T1_PACKED, modules, layout)
+
+    // Lane lists must exist
+    expect(result.gathererLanes).toBeDefined()
+    expect(result.gathererLanes!.length).toBe(2)
+
+    // Each lane has the right slotIndex
+    expect(result.gathererLanes![0].slotIndex).toBe(0)
+    expect(result.gathererLanes![1].slotIndex).toBe(1)
+
+    // Yields are amp-scaled and distinct
+    const caps1 = computeGathererCapabilities({strength: 300, tolerance: 200, conductivity: 400}, 1)
+    const caps2 = computeGathererCapabilities({strength: 500, tolerance: 100, conductivity: 300}, 1)
+    const expectedYield1 = applySlotMultiplier(caps1.yield, 100)
+    const expectedYield2 = applySlotMultiplier(caps2.yield, 100)
+    expect(result.gathererLanes![0].yield).toBe(expectedYield1)
+    expect(result.gathererLanes![1].yield).toBe(expectedYield2)
+    expect(result.gathererLanes![0].yield).not.toBe(result.gathererLanes![1].yield)
+
+    // Unscaled per-module drain and depth carried verbatim from the compute helper
+    expect(result.gathererLanes![0].drain).toBe(caps1.drain)
+    expect(result.gathererLanes![1].drain).toBe(caps2.drain)
+    expect(result.gathererLanes![0].depth).toBe(caps1.depth)
+    expect(result.gathererLanes![1].depth).toBe(caps2.depth)
+
+    // outputPct reflects the slot amp
+    expect(result.gathererLanes![0].outputPct).toBe(100)
+    expect(result.gathererLanes![1].outputPct).toBe(100)
+
+    // Legacy sum still equals sum of both lane yields
+    expect(result.gatherer).toBeDefined()
+    expect(result.gatherer!.yield).toBe(expectedYield1 + expectedYield2)
+})
+
+test('computeEntityCapabilities emits crafterLanes alongside legacy crafter sum', () => {
+    const crafterStats = makeCrafterStats(400, 300)
+
+    const modules: InstalledModule[] = [
+        {slotIndex: 0, itemId: ITEM_CRAFTER_T1, stats: crafterStats},
+    ]
+
+    const layout: EntitySlot[] = [{type: 'crafter', outputPct: 120}]
+
+    const result = computeEntityCapabilities({}, ITEM_EXTRACTOR_T1_PACKED, modules, layout)
+
+    expect(result.crafterLanes).toBeDefined()
+    expect(result.crafterLanes!.length).toBe(1)
+    expect(result.crafterLanes![0].slotIndex).toBe(0)
+
+    const caps = computeCrafterCapabilities({reactivity: 400, fineness: 300})
+    const expectedSpeed = applySlotMultiplier(caps.speed, 120)
+    expect(result.crafterLanes![0].speed).toBe(expectedSpeed)
+    expect(result.crafterLanes![0].drain).toBe(caps.drain)
+    expect(result.crafterLanes![0].outputPct).toBe(120)
+
+    // Legacy crafter speed equals single-lane speed
+    expect(result.crafter).toBeDefined()
+    expect(result.crafter!.speed).toBe(expectedSpeed)
+})
+
+test('computeEntityCapabilities emits loaderLanes alongside legacy loaders sum', () => {
+    const loaderStats = makeLoaderStats(600, 500)
+
+    const modules: InstalledModule[] = [{slotIndex: 0, itemId: ITEM_LOADER_T1, stats: loaderStats}]
+
+    const layout: EntitySlot[] = [{type: 'loader', outputPct: 80}]
+
+    const result = computeEntityCapabilities({}, ITEM_EXTRACTOR_T1_PACKED, modules, layout)
+
+    expect(result.loaderLanes).toBeDefined()
+    expect(result.loaderLanes!.length).toBe(1)
+    expect(result.loaderLanes![0].slotIndex).toBe(0)
+
+    const caps = computeLoaderCapabilities({insulation: 600, plasticity: 500})
+    // mass is unscaled (raw); thrust is amp-scaled
+    expect(result.loaderLanes![0].mass).toBe(caps.mass)
+    expect(result.loaderLanes![0].thrust).toBe(applySlotMultiplier(caps.thrust, 80))
+    expect(result.loaderLanes![0].outputPct).toBe(80)
+
+    // Legacy loaders.mass is total (same as single-lane raw mass here)
+    expect(result.loaders).toBeDefined()
+    expect(result.loaders!.mass).toBe(caps.mass)
+})
+
+test('per-lane amp-scaled stats clamp to UInt16, matching the contract clamp_to_uint16', () => {
+    expect(applySlotMultiplier(60000, 200)).toBe(U16_MAX)
+    expect(applySlotMultiplier(1000, 150)).toBe(1500)
+})

package/src/derivation/capabilities.ts

@@ -6,8 +6,8 @@ export function computeShipHullCapabilities(stats: Record<string, number>): {
     hullmass: number
     capacity: number
 } {
-    const statSum = stats.strength + stats.hardness + stats.cohesion
-    const exponent = statSum / 2997.0
+    const statSum = (stats.strength ?? 0) + (stats.hardness ?? 0)
+    const exponent = statSum / 1998.0
     return {
         hullmass: computeBaseHullmass(stats),
         capacity: Math.floor(5000000 * 6 ** exponent),
@@ -184,9 +184,9 @@ import type {EntitySlot} from '../data/recipes-runtime'
 export function computeBaseCapacity(itemId: number, stats: Record<string, number>): number {
     switch (itemId) {
         case ITEM_SHIP_T1_PACKED:
+            return computeShipHullCapabilities(stats).capacity
         case ITEM_EXTRACTOR_T1_PACKED:
         case ITEM_FACTORY_T1_PACKED:
-            return computeShipHullCapabilities(stats).capacity
         case ITEM_CONTAINER_T1_PACKED:
             return computeContainerCapabilities(stats).capacity
         case ITEM_WAREHOUSE_T1_PACKED:
@@ -209,22 +209,47 @@ export function computeWarehouseHullCapabilities(stats: Record<string, number>):
     hullmass: number
     capacity: number
 } {
-    const statSum = stats.strength + stats.hardness + stats.cohesion
-    const exponent = statSum / 2997.0
+    const statSum = (stats.strength ?? 0) + (stats.hardness ?? 0)
+    const exponent = statSum / 1998.0
     return {
         hullmass: computeBaseHullmass(stats),
         capacity: Math.floor(100000000 * 6 ** exponent),
     }
 }
 
+export interface GathererLaneEntry {
+    slotIndex: number
+    yield: number
+    drain: number
+    depth: number
+    outputPct: number
+}
+
+export interface CrafterLaneEntry {
+    slotIndex: number
+    speed: number
+    drain: number
+    outputPct: number
+}
+
+export interface LoaderLaneEntry {
+    slotIndex: number
+    mass: number
+    thrust: number
+    outputPct: number
+}
+
 export interface ComputedCapabilities {
     hullmass: number
     capacity: number
     engines?: {thrust: number; drain: number}
     generator?: {capacity: number; recharge: number}
     gatherer?: {yield: number; drain: number; depth: number}
+    gathererLanes?: GathererLaneEntry[]
     loaders?: {mass: number; thrust: number; quantity: number}
+    loaderLanes?: LoaderLaneEntry[]
     crafter?: {speed: number; drain: number}
+    crafterLanes?: CrafterLaneEntry[]
     hauler?: {capacity: number; efficiency: number; drain: number}
     warp?: {range: number}
 }
@@ -272,6 +297,10 @@ export function computeEntityCapabilities(
     let totalBatteryStatSum = 0
     let batteryCount = 0
 
+    const gathererLanes: GathererLaneEntry[] = []
+    const crafterLanes: CrafterLaneEntry[] = []
+    const loaderLanes: LoaderLaneEntry[] = []
+
     for (const mod of modules) {
         const item = getItem(mod.itemId)
         const modType = getModuleCapabilityType(mod.itemId)
@@ -293,23 +322,44 @@ export function computeEntityCapabilities(
             hasGatherer = true
             const tier = item.tier
             const caps = computeGathererCapabilities(decodedStats, tier)
-            totalGathYield += applySlotMultiplier(caps.yield, amp)
+            const scaledYield = applySlotMultiplier(caps.yield, amp)
+            totalGathYield += scaledYield
             totalGathDrain += caps.drain
             if (caps.depth > maxGathDepth) maxGathDepth = caps.depth
+            gathererLanes.push({
+                slotIndex: mod.slotIndex,
+                yield: scaledYield,
+                drain: caps.drain,
+                depth: caps.depth,
+                outputPct: amp,
+            })
         } else if (modType === MODULE_LOADER) {
             hasLoader = true
             const caps = computeLoaderCapabilities(decodedStats)
             totalLoaderMass += caps.mass
             totalLoaderThrust += applySlotMultiplier(caps.thrust, amp)
             totalLoaderQuantity += caps.quantity
+            loaderLanes.push({
+                slotIndex: mod.slotIndex,
+                mass: caps.mass,
+                thrust: applySlotMultiplier(caps.thrust, amp),
+                outputPct: amp,
+            })
         } else if (modType === MODULE_STORAGE) {
             const caps = computeStorageCapabilities(decodedStats, baseCapacity)
             totalStorageBonus += caps.capacityBonus
         } else if (modType === MODULE_CRAFTER) {
             hasCrafter = true
             const caps = computeCrafterCapabilities(decodedStats)
-            totalCrafterSpeed += applySlotMultiplier(caps.speed, amp)
+            const scaledSpeed = applySlotMultiplier(caps.speed, amp)
+            totalCrafterSpeed += scaledSpeed
             totalCrafterDrain += caps.drain
+            crafterLanes.push({
+                slotIndex: mod.slotIndex,
+                speed: scaledSpeed,
+                drain: caps.drain,
+                outputPct: amp,
+            })
         } else if (modType === MODULE_HAULER) {
             hasHauler = true
             const caps = computeHaulerCapabilities(decodedStats)
@@ -357,6 +407,7 @@ export function computeEntityCapabilities(
             drain: totalGathDrain,
             depth: maxGathDepth,
         }
+        result.gathererLanes = gathererLanes
     }
     if (hasLoader) {
         result.loaders = {
@@ -364,9 +415,11 @@ export function computeEntityCapabilities(
             thrust: clampUint16(totalLoaderThrust),
             quantity: totalLoaderQuantity,
         }
+        result.loaderLanes = loaderLanes
     }
     if (hasCrafter) {
         result.crafter = {speed: clampUint16(totalCrafterSpeed), drain: totalCrafterDrain}
+        result.crafterLanes = crafterLanes
     }
     if (hasHauler) {
         const efficiency =
@@ -388,8 +441,8 @@ export function computeContainerCapabilities(stats: Record<string, number>): {
     hullmass: number
     capacity: number
 } {
-    const statSum = stats.strength + stats.hardness + stats.cohesion
-    const exponent = statSum / 2997.0
+    const statSum = (stats.strength ?? 0) + (stats.hardness ?? 0)
+    const exponent = statSum / 1998.0
     return {
         hullmass: computeBaseHullmass(stats),
         capacity: Math.floor(22000000 * 6 ** exponent),
@@ -400,14 +453,13 @@ export function computeContainerT2Capabilities(stats: Record<string, number>): {
     hullmass: number
     capacity: number
 } {
-    const strength = stats.strength
-    const density = stats.density
-    const hardness = stats.hardness
-    const cohesion = stats.cohesion
+    const strength = stats.strength ?? 0
+    const density = stats.density ?? 0
+    const hardness = stats.hardness ?? 0
 
     const hullmass = 70000 - 50 * density
 
-    const statSum = strength + hardness + cohesion
+    const statSum = strength + hardness
     const exponent = statSum / 2947
     const capacity = Math.floor(24000000 * 6 ** exponent)
 

package/src/derivation/rollups.test.ts

@@ -0,0 +1,55 @@
+import {describe, expect, test} from 'bun:test'
+import {ServerContract} from '../contracts'
+import {rollupGatherer, rollupCrafter, rollupLoaders} from './rollups'
+
+const gLane = (slot: number, y: number, d: number, depth: number) =>
+    ServerContract.Types.gatherer_lane.from({
+        slot_index: slot,
+        yield: y,
+        drain: d,
+        depth,
+        output_pct: 100,
+    })
+const cLane = (slot: number, s: number, d: number) =>
+    ServerContract.Types.crafter_lane.from({slot_index: slot, speed: s, drain: d, output_pct: 100})
+const lLane = (slot: number, m: number, t: number) =>
+    ServerContract.Types.loader_lane.from({slot_index: slot, mass: m, thrust: t, output_pct: 100})
+
+describe('rollupGatherer', () => {
+    test('empty → undefined', () => {
+        expect(rollupGatherer([])).toBeUndefined()
+    })
+    test('sums yield/drain, takes MAX depth', () => {
+        const r = rollupGatherer([gLane(2, 300, 1250, 500), gLane(3, 250, 1000, 5495)])!
+        expect(r.yield.toNumber()).toBe(550)
+        expect(r.drain.toNumber()).toBe(2250)
+        expect(r.depth.toNumber()).toBe(5495)
+    })
+    test('clamps summed yield to uint16', () => {
+        const r = rollupGatherer([gLane(2, 60000, 0, 1), gLane(3, 60000, 0, 1)])!
+        expect(r.yield.toNumber()).toBe(65535)
+    })
+})
+
+describe('rollupCrafter', () => {
+    test('empty → undefined', () => {
+        expect(rollupCrafter([])).toBeUndefined()
+    })
+    test('sums speed/drain', () => {
+        const r = rollupCrafter([cLane(2, 100, 30), cLane(3, 140, 25)])!
+        expect(r.speed.toNumber()).toBe(240)
+        expect(r.drain.toNumber()).toBe(55)
+    })
+})
+
+describe('rollupLoaders', () => {
+    test('empty → undefined', () => {
+        expect(rollupLoaders([])).toBeUndefined()
+    })
+    test('integer-averages mass, sums thrust, counts quantity', () => {
+        const r = rollupLoaders([lLane(2, 200, 5), lLane(3, 201, 7)])!
+        expect(r.mass.toNumber()).toBe(200) // floor(401/2)
+        expect(r.thrust.toNumber()).toBe(12)
+        expect(r.quantity.toNumber()).toBe(2)
+    })
+})