@shipload/sdk 1.0.0-next.41 → 1.0.0-next.43

package/lib/shipload.js

@@ -3690,7 +3690,7 @@ var recipes = [
 				quantity: 300
 			},
 			{
-				itemId: 10006,
+				itemId: 10010,
 				quantity: 300
 			}
 		],
@@ -4206,149 +4206,6 @@ var recipes = [
 		],
 		blendWeights: [
 		]
-	},
-	{
-		outputItemId: 20001,
-		outputMass: 500,
-		inputs: [
-			{
-				itemId: 10001,
-				quantity: 200
-			},
-			{
-				itemId: 102,
-				quantity: 15
-			}
-		],
-		statSlots: [
-			{
-				sources: [
-					{
-						inputIndex: 0,
-						statIndex: 0
-					},
-					{
-						inputIndex: 1,
-						statIndex: 0
-					}
-				]
-			},
-			{
-				sources: [
-					{
-						inputIndex: 0,
-						statIndex: 1
-					},
-					{
-						inputIndex: 1,
-						statIndex: 2
-					}
-				]
-			}
-		],
-		blendWeights: [
-			1,
-			1
-		]
-	},
-	{
-		outputItemId: 20002,
-		outputMass: 300,
-		inputs: [
-			{
-				itemId: 10002,
-				quantity: 200
-			},
-			{
-				itemId: 402,
-				quantity: 10
-			},
-			{
-				itemId: 502,
-				quantity: 20
-			}
-		],
-		statSlots: [
-			{
-				sources: [
-					{
-						inputIndex: 0,
-						statIndex: 0
-					},
-					{
-						inputIndex: 1,
-						statIndex: 1
-					}
-				]
-			},
-			{
-				sources: [
-					{
-						inputIndex: 0,
-						statIndex: 1
-					},
-					{
-						inputIndex: 2,
-						statIndex: 2
-					}
-				]
-			}
-		],
-		blendWeights: [
-			1,
-			1,
-			1
-		]
-	},
-	{
-		outputItemId: 20200,
-		outputMass: 80000,
-		inputs: [
-			{
-				itemId: 20001,
-				quantity: 600
-			},
-			{
-				itemId: 20002,
-				quantity: 200
-			}
-		],
-		statSlots: [
-			{
-				sources: [
-					{
-						inputIndex: 0,
-						statIndex: 0
-					}
-				]
-			},
-			{
-				sources: [
-					{
-						inputIndex: 0,
-						statIndex: 1
-					}
-				]
-			},
-			{
-				sources: [
-					{
-						inputIndex: 1,
-						statIndex: 0
-					}
-				]
-			},
-			{
-				sources: [
-					{
-						inputIndex: 1,
-						statIndex: 1
-					}
-				]
-			}
-		],
-		blendWeights: [
-		]
 	}
 ];
 
@@ -5606,6 +5463,21 @@ function deriveLocationSize(loc) {
     return Math.floor(LOCATION_MIN_DEPTH + curved * range);
 }
 
+const COORD_MIN = -2147483648;
+const COORD_MAX = 2147483647;
+const COORD_OFFSET = 2147485000;
+const SECTOR_DIV = 100000000;
+const REGION_DIV = 10000;
+const SECTORS_PER_AXIS = 43;
+const REGION_PER_AXIS = 10000;
+const LOCAL_HALF = 5000;
+const LOCAL_MIN = -5000;
+const LOCAL_MAX = 4999;
+const SECTOR_COUNT = SECTORS_PER_AXIS * SECTORS_PER_AXIS;
+const REGION_COUNT = REGION_PER_AXIS * REGION_PER_AXIS;
+const SECTOR_FEISTEL = { n: SECTOR_COUNT, halfBits: 6, label: 'sector' };
+const REGION_FEISTEL = { n: REGION_COUNT, halfBits: 14, label: 'region' };
+
 const WH = {
     RSIZE: 75,
     ZONE: 16384,
@@ -5672,6 +5544,9 @@ function endpointInRegion(seed, R, key) {
 function dist$1(a, b) {
     return Math.sqrt((a.x - b.x) ** 2 + (a.y - b.y) ** 2);
 }
+function inBounds(c) {
+    return c.x >= COORD_MIN && c.x <= COORD_MAX && c.y >= COORD_MIN && c.y <= COORD_MAX;
+}
 function wormholeOfRegion(seed, R) {
     const P = partnerRegion(seed, R);
     if (P.rx === R.rx && P.ry === R.ry)
@@ -5681,6 +5556,8 @@ function wormholeOfRegion(seed, R) {
         return null;
     const A = endpointInRegion(seed, R, key);
     const B = endpointInRegion(seed, P, key);
+    if (!inBounds(A) || !inBounds(B))
+        return null;
     if (dist$1(A, B) < WH.MIN_REACH)
         return null;
     return { A, B };
@@ -9316,6 +9193,14 @@ class EntitiesManager extends BaseManager {
         const entities = result;
         return entities.map((e) => new Entity(e));
     }
+    async getAllEntities(kind) {
+        const rows = await this.server.table('entity').all();
+        if (!kind) {
+            return rows;
+        }
+        const wanted = antelope.Name.from(kind);
+        return rows.filter((row) => wanted.equals(row.kind));
+    }
     async getSummaries(owner, kind) {
         const ownerName = this.resolveOwner(owner);
         const result = await this.server.readonly('getsummaries', {
@@ -9349,6 +9234,24 @@ class PlayersManager extends BaseManager {
         }
         return new Player(playerRow);
     }
+    async getPlayers() {
+        const rows = await this.server.table('player').all();
+        return rows.map((row) => new Player(row));
+    }
+    async getRoster() {
+        const [players, companies] = await Promise.all([
+            this.server.table('player').all(),
+            this.platform.table('company').all(),
+        ]);
+        const companyNames = new Map();
+        for (const company of companies) {
+            companyNames.set(company.account.toString(), company.name);
+        }
+        return players.map((player) => ({
+            owner: player.owner,
+            company: companyNames.get(player.owner.toString()),
+        }));
+    }
 }
 
 const RESERVE_TIERS = {
@@ -9999,21 +9902,6 @@ class LocationsManager extends BaseManager {
     }
 }
 
-const COORD_MIN = -2147483648;
-const COORD_MAX = 2147483647;
-const COORD_OFFSET = 2147485000;
-const SECTOR_DIV = 100000000;
-const REGION_DIV = 10000;
-const SECTORS_PER_AXIS = 43;
-const REGION_PER_AXIS = 10000;
-const LOCAL_HALF = 5000;
-const LOCAL_MIN = -5000;
-const LOCAL_MAX = 4999;
-const SECTOR_COUNT = SECTORS_PER_AXIS * SECTORS_PER_AXIS;
-const REGION_COUNT = REGION_PER_AXIS * REGION_PER_AXIS;
-const SECTOR_FEISTEL = { n: SECTOR_COUNT, halfBits: 6, label: 'sector' };
-const REGION_FEISTEL = { n: REGION_COUNT, halfBits: 14, label: 'region' };
-
 const ROUNDS = 4;
 const keyCache = new Map();
 function deriveRoundKeys(seed, label) {
@@ -12581,6 +12469,19 @@ class ActionsManager extends BaseManager {
             },
         }, ATOMICASSETS_ABI);
     }
+    sendAsset(owner, recipient, assetId, memo = '') {
+        return antelope.Action.from({
+            account: this.atomicAssetsAccount,
+            name: 'transfer',
+            authorization: [{ actor: antelope.Name.from(owner), permission: 'active' }],
+            data: {
+                from: antelope.Name.from(owner),
+                to: antelope.Name.from(recipient),
+                asset_ids: [antelope.UInt64.from(assetId)],
+                memo,
+            },
+        }, ATOMICASSETS_ABI);
+    }
     unwrapCargoTx(owner, assetId, hostId) {
         return [this.transferForUnwrap(owner, assetId), this.placecargo(owner, hostId, assetId)];
     }
@@ -13549,7 +13450,7 @@ function gathererDepthForTier(tol, tier) {
 }
 function computeGathererCapabilities(stats, tier) {
     const str = stats.strength;
-    const con = stats.conductivity;
+    const con = stats.saturation;
     const tol = stats.tolerance;
     return {
         yield: 200 + str,
@@ -14547,8 +14448,23 @@ function reconstruct(cameFrom, origin, dest) {
     const waypoints = path.slice(1);
     return { ok: true, waypoints, legs: waypoints.length, totalDistance };
 }
+let scanProvider = null;
+const graphCache = new Map();
+function setScanProvider(provider) {
+    scanProvider = provider;
+    graphCache.clear();
+}
 function sdkSystemGraph(seed) {
     const s = antelope.Checksum256.from(seed);
+    const seedHex = s.toString();
+    const cached = graphCache.get(seedHex);
+    if (cached)
+        return cached;
+    const graph = scanProvider ? wasmSystemGraph(s, seedHex, scanProvider) : jsSystemGraph(s);
+    graphCache.set(seedHex, graph);
+    return graph;
+}
+function jsSystemGraph(s) {
     return {
         hasSystem: (c) => hasSystem(s, { x: c.x, y: c.y }) || wormholeAt(s, c.x, c.y) !== null,
         nearby: (c, reachTiles) => {
@@ -14573,6 +14489,57 @@ function sdkSystemGraph(seed) {
         },
     };
 }
+const SCAN_BUCKET = 48;
+function wasmSystemGraph(s, seedHex, scan) {
+    const bucketCache = new Map();
+    const bucketSystems = (bx, by) => {
+        const k = `${bx},${by}`;
+        let v = bucketCache.get(k);
+        if (v === undefined) {
+            const xMin = bx * SCAN_BUCKET;
+            const yMin = by * SCAN_BUCKET;
+            v = scan
+                .systemsInBox(seedHex, xMin, yMin, xMin + SCAN_BUCKET - 1, yMin + SCAN_BUCKET - 1)
+                .map((cell) => ({ x: cell.x, y: cell.y }));
+            bucketCache.set(k, v);
+        }
+        return v;
+    };
+    return {
+        hasSystem: (c) => scan.getLocationType(seedHex, c.x, c.y) !== 0 || wormholeAt(s, c.x, c.y) !== null,
+        nearby: (c, reachTiles) => {
+            const r = Math.floor(reachTiles);
+            const seen = new Set([`${c.x},${c.y}`]);
+            const out = [];
+            const bx0 = Math.floor((c.x - r) / SCAN_BUCKET);
+            const bx1 = Math.floor((c.x + r) / SCAN_BUCKET);
+            const by0 = Math.floor((c.y - r) / SCAN_BUCKET);
+            const by1 = Math.floor((c.y + r) / SCAN_BUCKET);
+            for (let bx = bx0; bx <= bx1; bx++) {
+                for (let by = by0; by <= by1; by++) {
+                    for (const cell of bucketSystems(bx, by)) {
+                        const dist = Math.hypot(cell.x - c.x, cell.y - c.y);
+                        if (dist > reachTiles)
+                            continue;
+                        const k = `${cell.x},${cell.y}`;
+                        if (seen.has(k))
+                            continue;
+                        seen.add(k);
+                        out.push({ coord: { x: cell.x, y: cell.y }, dist });
+                    }
+                }
+            }
+            for (const coord of nearbyWormholes(s, c.x, c.y, reachTiles)) {
+                const k = `${coord.x},${coord.y}`;
+                if (seen.has(k))
+                    continue;
+                seen.add(k);
+                out.push({ coord, dist: Math.hypot(coord.x - c.x, coord.y - c.y) });
+            }
+            return out;
+        },
+    };
+}
 
 function computePerLegReach(s, haulCount = 0) {
     const capacity = s.generator?.capacity;
@@ -15612,6 +15579,117 @@ function cancelEligibility(entity, laneKey, fromTaskIndex, input) {
     return { ok: true, range, effects };
 }
 
+const NFT_TRANSIT_THRUST = 400;
+function derivedLoaders(lanes) {
+    if (!lanes || lanes.length === 0)
+        return null;
+    let totalMass = 0;
+    let totalThrust = 0;
+    for (const l of lanes) {
+        totalMass += Number(l.mass);
+        totalThrust += Number(l.thrust);
+    }
+    const count = lanes.length;
+    return {
+        mass: Math.floor(totalMass / count),
+        thrust: Math.min(totalThrust, 65535),
+        quantity: count,
+    };
+}
+function acceleration(thrust, mass) {
+    if (mass <= 0)
+        return 0;
+    return (thrust / mass) * PRECISION$1;
+}
+function flightTime(distance, accel) {
+    if (accel <= 0 || distance <= 0)
+        return 0;
+    return Math.floor(2 * Math.sqrt(distance / accel));
+}
+function distance2d(ax, ay, bx, by) {
+    const dx = ax - bx;
+    const dy = ay - by;
+    return Math.floor(Math.sqrt(dx * dx + dy * dy) * PRECISION$1);
+}
+function unwrapTransitDuration(itemMass, origin, dest) {
+    if (itemMass <= 0)
+        return 0;
+    return flightTime(distance2d(origin.x, origin.y, dest.x, dest.y), acceleration(NFT_TRANSIT_THRUST, itemMass));
+}
+function unwrapLoadDuration(loaders, itemMass, destZ) {
+    if (!loaders || itemMass <= 0)
+        return 0;
+    const total = itemMass + loaders.mass;
+    const flight = flightTime(destZ, acceleration(loaders.thrust, total));
+    return Math.floor(flight / loaders.quantity);
+}
+function estimateUnwrapDuration(dest, item) {
+    const itemMass = Number(calcCargoItemMass({
+        item_id: item.itemId,
+        quantity: item.quantity,
+        modules: item.modules,
+    }));
+    const loaders = derivedLoaders(dest.loader_lanes);
+    const dz = Number(dest.coordinates.z ?? 0);
+    const load = unwrapLoadDuration(loaders, itemMass, dz);
+    const transit = unwrapTransitDuration(itemMass, { x: item.originX, y: item.originY }, {
+        x: Number(dest.coordinates.x),
+        y: Number(dest.coordinates.y),
+    });
+    return load + transit;
+}
+const INCOMING_HOLD_KINDS = new Set([2, 3, 5]);
+function incomingHoldMass(holds) {
+    if (!holds)
+        return 0;
+    let total = 0;
+    for (const h of holds) {
+        if (INCOMING_HOLD_KINDS.has(Number(h.kind)))
+            total += Number(h.incoming_mass);
+    }
+    return total;
+}
+function cargoListMass(items) {
+    let m = 0;
+    for (const it of items)
+        m += Number(calcCargoItemMass(it));
+    return m;
+}
+function projectedPeakCargomass(entity, at, addMass, removeMass = 0) {
+    const events = [];
+    for (const ordered of orderedTasks(entity)) {
+        const eff = taskCargoEffect(ordered.task);
+        const delta = cargoListMass(eff.added) - cargoListMass(eff.removed);
+        events.push({ t: ordered.completesAt.getTime(), delta });
+    }
+    events.push({ t: at.getTime(), delta: addMass - removeMass });
+    events.sort((a, b) => (a.t !== b.t ? a.t - b.t : b.delta - a.delta));
+    let running = Number(entity.cargomass);
+    let peak = running;
+    for (const e of events) {
+        running += e.delta;
+        if (running < 0)
+            running = 0;
+        if (running > peak)
+            peak = running;
+    }
+    return Math.min(peak, 4294967295);
+}
+function receiveFits(dest, item, now) {
+    const capacity = Number(dest.capacity ?? 0);
+    if (capacity <= 0)
+        return false;
+    const itemMass = Number(calcCargoItemMass({
+        item_id: item.itemId,
+        quantity: item.quantity,
+        modules: item.modules,
+    }));
+    const duration = estimateUnwrapDuration(dest, item);
+    const candidateCompletes = candidateLaneCompletesAt(dest, LANE_MOBILITY, duration, now);
+    const peak = projectedPeakCargomass(dest, candidateCompletes, itemMass + incomingHoldMass(dest.holds));
+    return peak <= capacity;
+}
+
 function maxCraftable(entity, recipe, crafterSpeed, now) {
     if (recipe.inputs.length === 0)
         return 0;
@@ -16055,6 +16133,10 @@ function traceToRawCategoryStat(recipe, source, visited = new Set()) {
     nextVisited.add(input.itemId);
     return traceToRawCategoryStat(subRecipe, subSource, nextVisited);
 }
+function sourceLabelForOutput(itemId) {
+    const item = getItem(itemId);
+    return item.type === 'entity' ? 'Hull' : item.name;
+}
 let cached;
 function deriveStatMappings() {
     if (cached)
@@ -16066,16 +16148,17 @@ function deriveStatMappings() {
         const recipe = getRecipe(itemId);
         if (!recipe)
             continue;
+        const source = sourceLabelForOutput(itemId);
         for (const [slotIdxStr, consumer] of Object.entries(slots)) {
             const slotIdx = Number(slotIdxStr);
             const slot = recipe.statSlots[slotIdx];
             if (!slot)
                 continue;
-            for (const source of slot.sources) {
-                const stat = traceToRawCategoryStat(recipe, source);
+            for (const src of slot.sources) {
+                const stat = traceToRawCategoryStat(recipe, src);
                 if (!stat)
                     continue;
-                const key = `${stat.label}|${consumer.capability}|${consumer.attribute}`;
+                const key = `${stat.label}|${consumer.capability}|${consumer.attribute}|${source}`;
                 if (seen.has(key))
                     continue;
                 seen.add(key);
@@ -16083,6 +16166,7 @@ function deriveStatMappings() {
                     stat: stat.label,
                     capability: consumer.capability,
                     attribute: consumer.attribute,
+                    source,
                 });
             }
         }
@@ -16099,6 +16183,42 @@ function getStatMappingsForStat(stat) {
 function getStatMappingsForCapability(capability) {
     return deriveStatMappings().filter((m) => m.capability === capability);
 }
+function getProducersForAttribute(capability, attribute) {
+    const seen = new Set();
+    const out = [];
+    for (const m of deriveStatMappings()) {
+        if (m.capability !== capability || m.attribute !== attribute)
+            continue;
+        if (seen.has(m.source))
+            continue;
+        seen.add(m.source);
+        out.push(m.source);
+    }
+    return out;
+}
+function getCapabilityAttributeRows() {
+    const rows = [];
+    for (const ca of capabilityAttributes) {
+        const producers = getProducersForAttribute(ca.capability, ca.attribute);
+        if (producers.length === 0) {
+            rows.push({
+                capability: ca.capability,
+                attribute: ca.attribute,
+                description: ca.description,
+            });
+            continue;
+        }
+        for (const source of producers) {
+            rows.push({
+                capability: ca.capability,
+                attribute: ca.attribute,
+                description: ca.description,
+                source,
+            });
+        }
+    }
+    return rows;
+}
 
 function getAllRecipes() {
     return recipes;
@@ -16803,8 +16923,8 @@ function buildModuleImmutable(itemId, quantity, stats, originX, originY) {
             const ref = decodeStat(stats, 3);
             base.push({ first: 'strength', second: ['uint16', str] });
             base.push({ first: 'tolerance', second: ['uint16', tol] });
-            base.push({ first: 'conductivity', second: ['uint16', con] });
-            base.push({ first: 'reflectivity', second: ['uint16', ref] });
+            base.push({ first: 'saturation', second: ['uint16', con] });
+            base.push({ first: 'plasticity', second: ['uint16', ref] });
             base.push({ first: 'yield', second: ['uint16', computeGathererYield(str)] });
             base.push({ first: 'drain', second: ['uint16', computeGathererDrain(con)] });
             base.push({ first: 'depth', second: ['uint16', computeGathererDepth(tol, item.tier)] });
@@ -17523,6 +17643,7 @@ exports.deriveResourceStats = deriveResourceStats;
 exports.deriveStatMappings = deriveStatMappings;
 exports.deriveStrata = deriveStrata;
 exports.deriveStratum = deriveStratum;
+exports.derivedLoaders = derivedLoaders;
 exports.describeItem = describeItem;
 exports.describeModule = describeModule;
 exports.describeModuleForItem = describeModuleForItem;
@@ -17548,6 +17669,7 @@ exports.energyPercent = energyPercent;
 exports.entityDisplayName = entityDisplayName;
 exports.estimateDealTravelTime = estimateDealTravelTime;
 exports.estimateTravelTime = estimateTravelTime;
+exports.estimateUnwrapDuration = estimateUnwrapDuration;
 exports.feistel = feistel;
 exports.feistelInv = feistelInv;
 exports.fetchAtomicAssetsForOwner = fetchAtomicAssetsForOwner;
@@ -17563,6 +17685,7 @@ exports.formatModuleLine = formatModuleLine;
 exports.formatTier = formatTier;
 exports.gathererDepthForTier = gathererDepthForTier;
 exports.getAllRecipes = getAllRecipes;
+exports.getCapabilityAttributeRows = getCapabilityAttributeRows;
 exports.getCapabilityAttributes = getCapabilityAttributes;
 exports.getCategoryInfo = getCategoryInfo;
 exports.getComponentDemand = getComponentDemand;
@@ -17592,6 +17715,7 @@ exports.getPackedEntityType = getPackedEntityType;
 exports.getPlanetSubtype = getPlanetSubtype;
 exports.getPlanetSubtypes = getPlanetSubtypes;
 exports.getPositionAt = getPositionAt;
+exports.getProducersForAttribute = getProducersForAttribute;
 exports.getRecipe = getRecipe;
 exports.getRecipeConsumers = getRecipeConsumers;
 exports.getResourceDemand = getResourceDemand;
@@ -17617,6 +17741,7 @@ exports.hasStorage = hasStorage;
 exports.hasSystem = hasSystem;
 exports.hash = hash;
 exports.hash512 = hash512;
+exports.incomingHoldMass = incomingHoldMass;
 exports.interpolateFlightPosition = interpolateFlightPosition;
 exports.isBuildable = isBuildable;
 exports.isContainer = isContainer;
@@ -17655,6 +17780,7 @@ exports.moduleAccepts = moduleAccepts;
 exports.moduleDisplayName = moduleDisplayName;
 exports.moduleIcon = moduleIcon;
 exports.moduleSlotTypeToCode = moduleSlotTypeToCode;
+exports.nearbyWormholes = nearbyWormholes;
 exports.needsRecharge = needsRecharge;
 exports.normalizeDisplayName = normalizeDisplayName;
 exports.parseWireEntity = parseWireEntity;
@@ -17666,8 +17792,10 @@ exports.projectEntity = projectEntity;
 exports.projectEntityAt = projectEntityAt;
 exports.projectRemainingAt = projectRemainingAt;
 exports.projectedCargoAvailableAt = projectedCargoAvailableAt;
+exports.projectedPeakCargomass = projectedPeakCargomass;
 exports.rawScheduleEnd = rawScheduleEnd;
 exports.readCommonBase = readCommonBase;
+exports.receiveFits = receiveFits;
 exports.regionOf = regionOf;
 exports.removeFromStacks = removeFromStacks;
 exports.renderDescription = renderDescription;
@@ -17687,7 +17815,9 @@ exports.rotation = rotation;
 exports.schedule = schedule;
 exports.sdkSystemGraph = sdkSystemGraph;
 exports.selectGatherLane = selectGatherLane;
+exports.setScanProvider = setScanProvider;
 exports.setSubscriptionsDebug = setSubscriptionsDebug;
+exports.sourceLabelForOutput = sourceLabelForOutput;
 exports.stackKey = stackKey;
 exports.stackToCargoItem = stackToCargoItem;
 exports.stacksEqual = stacksEqual;
@@ -17702,6 +17832,8 @@ exports.tierColors = tierColors;
 exports.tierOfReserve = tierOfReserve;
 exports.toLocation = toLocation;
 exports.typeLabel = typeLabel;
+exports.unwrapLoadDuration = unwrapLoadDuration;
+exports.unwrapTransitDuration = unwrapTransitDuration;
 exports.validateDisplayName = validateDisplayName;
 exports.validateSchedule = validateSchedule;
 exports.workerLaneKey = workerLaneKey;