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

package/lib/shipload.d.ts

@@ -4633,7 +4633,7 @@ interface SlotConsumer {
     capability: string;
     attribute: string;
 }
-type SlotConsumerKind = 'engine' | 'generator' | 'gatherer' | 'loader' | 'crafter' | 'storage' | 'hauler' | 'warp' | 'battery' | 'ship-t1' | 'container-t1' | 'warehouse-t1' | 'extractor-t1' | 'container-t2';
+type SlotConsumerKind = 'engine' | 'generator' | 'gatherer' | 'loader' | 'crafter' | 'builder' | 'storage' | 'hauler' | 'warp' | 'battery' | 'ship-t1' | 'container-t1' | 'warehouse-t1' | 'extractor-t1' | 'container-t2';
 declare const SLOT_FORMULAS: Record<SlotConsumerKind, Record<number, SlotConsumer>>;
 
 declare function sourceLabelForOutput(itemId: number): string;
@@ -5016,8 +5016,8 @@ declare const computeLoaderMass: (ins: number) => number;
 declare const computeLoaderThrust: (pla: number) => number;
 declare const computeCrafterSpeed: (rea: number) => number;
 declare const computeCrafterDrain: (fin: number) => number;
-declare const computeBuilderSpeed: (coh: number) => number;
-declare const computeBuilderDrain: (tol: number) => number;
+declare const computeBuilderSpeed: (resonance: number) => number;
+declare const computeBuilderDrain: (fineness: number) => number;
 declare const computeHaulerCapacity: (fin: number, tier: number) => number;
 declare const computeHaulerEfficiency: (con: number) => number;
 declare const supportDrainTierPercent: (tier: number) => number;

package/lib/shipload.js

@@ -4641,33 +4641,39 @@ var recipes = [
 		outputMass: 960000,
 		inputs: [
 			{
-				itemId: 10005,
+				itemId: 10006,
 				quantity: 300
 			},
 			{
-				itemId: 10002,
+				itemId: 10008,
 				quantity: 300
 			}
 		],
 		statSlots: [
 			{
 				sources: [
+					{
+						inputIndex: 0,
+						statIndex: 2
+					},
 					{
 						inputIndex: 1,
-						statIndex: 1
+						statIndex: 0
 					}
 				]
 			},
 			{
 				sources: [
 					{
-						inputIndex: 0,
+						inputIndex: 1,
 						statIndex: 1
 					}
 				]
 			}
 		],
 		blendWeights: [
+			1,
+			1
 		]
 	},
 	{
@@ -16312,8 +16318,8 @@ const computeLoaderMass = (ins) => Math.max(200, 2000 - ins * 2);
 const computeLoaderThrust = (pla) => 1 + idiv(pla * pla, 10000);
 const computeCrafterSpeed = (rea) => 100 + idiv(rea * 4, 5);
 const computeCrafterDrain = (fin) => Math.max(5000, 30000 - idiv(fin * 1000, 33));
-const computeBuilderSpeed = (coh) => 100 + idiv(coh * 4, 5);
-const computeBuilderDrain = (tol) => Math.max(5000, 30000 - idiv(tol * 1000, 33));
+const computeBuilderSpeed = (resonance) => 100 + idiv(resonance * 4, 5);
+const computeBuilderDrain = (fineness) => Math.max(5000, 30000 - idiv(fineness * 1000, 33));
 const computeHaulerCapacity = (fin, tier) => Math.max(tier, tier + idiv(fin, 400));
 const computeHaulerEfficiency = (con) => 2000 + con * 6;
 const supportDrainTierPercent = (tier) => {
@@ -16434,9 +16440,9 @@ function formatModuleLine(slot, itemId, stats) {
             break;
         }
         case MODULE_BUILDER: {
-            const coh = decodeStat(stats, 0);
-            const tol = decodeStat(stats, 1);
-            out += `  Speed ${computeBuilderSpeed(coh)}  Drain ${toWholeEnergy$1(computeBuilderDrain(tol))}`;
+            const res = decodeStat(stats, 0);
+            const fin = decodeStat(stats, 1);
+            out += `  Speed ${computeBuilderSpeed(res)}  Drain ${toWholeEnergy$1(computeBuilderDrain(fin))}`;
             break;
         }
         case MODULE_STORAGE: {
@@ -16589,11 +16595,11 @@ function computeCrafterCapabilities(stats) {
     };
 }
 function computeBuilderCapabilities(stats) {
-    const coh = stats.cohesion;
-    const tol = stats.tolerance;
+    const resonance = stats.resonance;
+    const fineness = stats.fineness;
     return {
-        speed: 100 + Math.floor((coh * 4) / 5),
-        drain: Math.max(5000, 30000 - Math.floor((tol * 1000) / 33)),
+        speed: 100 + Math.floor((resonance * 4) / 5),
+        drain: Math.max(5000, 30000 - Math.floor((fineness * 1000) / 33)),
     };
 }
 function computeHaulerCapabilities(stats, tier) {
@@ -17904,12 +17910,12 @@ function resolveLaneBuilder(modules, entityItemId, laneKey) {
     if (item.moduleType !== 'builder')
         throw new Error('lane module is not a builder');
     const stats = BigInt(installed.stats.toString());
-    const coh = decodeStat(stats, 0);
-    const tol = decodeStat(stats, 1);
+    const res = decodeStat(stats, 0);
+    const fin = decodeStat(stats, 1);
     const layout = getEntityLayout(entityItemId)?.slots ?? [];
     const amp = getSlotAmp(layout, idx);
-    const speed = applySlotMultiplier(computeBuilderSpeed(coh), amp);
-    const drain = computeBuilderDrain(tol);
+    const speed = applySlotMultiplier(computeBuilderSpeed(res), amp);
+    const drain = computeBuilderDrain(fin);
     return { slotIndex: idx, speed, drain, outputPct: amp };
 }
 function resolveLaneLoader(modules, entityItemId, laneKey) {
@@ -19322,6 +19328,7 @@ const capabilityNames = [
     'Gathering',
     'Warp',
     'Crafting',
+    'Build',
     'Launch',
     'Hauling',
 ];
@@ -19367,6 +19374,12 @@ const capabilityAttributes = [
         description: 'Energy consumed per second while crafting',
     },
     { capability: 'Crafting', attribute: 'quality', description: 'Modifier on output quality' },
+    { capability: 'Build', attribute: 'speed', description: 'Build progress per second' },
+    {
+        capability: 'Build',
+        attribute: 'drain',
+        description: 'Energy consumed per second while building',
+    },
     { capability: 'Launch', attribute: 'range', description: 'Maximum launch distance' },
     { capability: 'Launch', attribute: 'capacity', description: 'Maximum mass per launch' },
     { capability: 'Launch', attribute: 'drain', description: 'Energy consumed per launch' },
@@ -19424,6 +19437,10 @@ const SLOT_FORMULAS = {
         0: { capability: 'Crafting', attribute: 'speed' },
         1: { capability: 'Crafting', attribute: 'drain' },
     },
+    builder: {
+        0: { capability: 'Build', attribute: 'speed' },
+        1: { capability: 'Build', attribute: 'drain' },
+    },
     storage: {
         0: { capability: 'Storage', attribute: 'capacity' },
         1: { capability: 'Storage', attribute: 'capacity' },
@@ -19457,6 +19474,7 @@ const KIND_TO_ITEM_ID = {
     gatherer: ITEM_GATHERER_T1,
     loader: ITEM_LOADER_T1,
     crafter: ITEM_CRAFTER_T1,
+    builder: ITEM_BUILDER_T1,
     storage: ITEM_STORAGE_T1,
     hauler: ITEM_HAULER_T1,
     warp: ITEM_WARP_T1,
@@ -20380,12 +20398,12 @@ function buildModuleImmutable(itemId, quantity, stats, originX, originY) {
             break;
         }
         case MODULE_BUILDER: {
-            const coh = decodeStat(stats, 0);
-            const tol = decodeStat(stats, 1);
-            base.push({ first: 'cohesion', second: ['uint16', coh] });
-            base.push({ first: 'tolerance', second: ['uint16', tol] });
-            base.push({ first: 'speed', second: ['uint16', computeBuilderSpeed(coh)] });
-            base.push({ first: 'drain', second: ['uint16', toWholeEnergy(computeBuilderDrain(tol))] });
+            const res = decodeStat(stats, 0);
+            const fin = decodeStat(stats, 1);
+            base.push({ first: 'resonance', second: ['uint16', res] });
+            base.push({ first: 'fineness', second: ['uint16', fin] });
+            base.push({ first: 'speed', second: ['uint16', computeBuilderSpeed(res)] });
+            base.push({ first: 'drain', second: ['uint16', toWholeEnergy(computeBuilderDrain(fin))] });
             break;
         }
         case MODULE_STORAGE: {