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

package/src/index-module.ts

@@ -29,6 +29,7 @@ export type energy_stats = ServerContract.Types.energy_stats
 export type schedule = ServerContract.Types.schedule
 export type lane = ServerContract.Types.lane
 export type task = ServerContract.Types.task
+export type coupling = ServerContract.Types.coupling
 export type cargo_item = ServerContract.Types.cargo_item
 export type entity_row = ServerContract.Types.entity_row
 
@@ -177,6 +178,8 @@ export {
     calc_acceleration,
     calc_energyusage,
     calc_flighttime,
+    calc_travel_flighttime,
+    calc_group_flighttime,
     calc_loader_acceleration,
     calc_loader_flighttime,
     calc_onesided_duration,
@@ -214,7 +217,7 @@ export type {
     HasScheduleAndLocation,
 } from './travel/travel'
 
-export {planRoute, sdkSystemGraph, setScanProvider, MAX_LEGS} from './travel/route-planner'
+export {planRoute, sdkSystemGraph, MAX_LEGS} from './travel/route-planner'
 export type {
     Coord,
     Neighbor,
@@ -225,11 +228,17 @@ export type {
     RouteResult,
     RouteFailureReason,
     PlanRouteParams,
+    RouteLegInput,
+    RouteLegCost,
+    RouteHeuristicCost,
 } from './travel/route-planner'
 
 export {computePerLegReach, computeGroupPerLegReach} from './travel/reach'
 export type {ReachStats} from './travel/reach'
 
+export {simulateRoute} from './travel/route-simulator'
+export type {RouteMoverInput, RouteLegSim, RouteSim} from './travel/route-simulator'
+
 export * as schedule from './scheduling/schedule'
 export {LANE_MOBILITY, LANE_BARRIER} from './scheduling/schedule'
 export type {
@@ -244,6 +253,7 @@ export {
     rawScheduleEnd,
     resolveLaneGatherer,
     resolveLaneCrafter,
+    resolveLaneBuilder,
     resolveLaneLoader,
     selectGatherLane,
     workerLaneKey,
@@ -278,6 +288,9 @@ export type {
 export {taskCargoChanges} from './scheduling/task-cargo'
 export type {TaskCargoChange, TaskCargoDirection} from './scheduling/task-cargo'
 
+export {jobsToLanes, pickFabricator, socketTail, JOB_QUEUE_CAP} from './scheduling/jobs'
+export type {JobWindow, JobLane, JobLaneEntry} from './scheduling/jobs'
+
 export {composeIdleResolve} from './scheduling/idle-resolve'
 export type {CounterpartLookup, IdleResolveTarget} from './scheduling/idle-resolve'
 
@@ -320,6 +333,7 @@ export {
     ENTITY_WAREHOUSE,
     ENTITY_EXTRACTOR,
     ENTITY_FACTORY,
+    ENTITY_WORKSHOP,
     ENTITY_CONTAINER,
     ENTITY_NEXUS,
     ENTITY_HUB,
@@ -337,6 +351,7 @@ export {
     isWarehouse,
     isExtractor,
     isFactory,
+    isWorkshop,
     isContainer,
     isNexus,
     isPlot,
@@ -424,6 +439,7 @@ export {
     computeHaulerCapabilities,
     computeLoaderCapabilities,
     computeCrafterCapabilities,
+    computeBuilderCapabilities,
     computeWarehouseHullCapabilities,
     computeStorageCapabilities,
     computeBatteryCapabilities,
@@ -432,6 +448,8 @@ export {
     computeLauncherCapabilities,
     computeBaseCapacity,
     computeEntityCapabilities,
+    getBaseHullmassFor,
+    DEFAULT_BASE_HULLMASS,
     CAPACITY_TIER_TABLE,
     capacityTierMultiplier,
     applyCapacityTier,
@@ -439,7 +457,11 @@ export {
     GATHERER_DEPTH_MAX_TIER,
     gathererDepthForTier,
 } from './derivation/capabilities'
-export type {GathererDepthParams, ComputedCapabilities} from './derivation/capabilities'
+export type {
+    GathererDepthParams,
+    ComputedCapabilities,
+    TravelDrainBreakdown,
+} from './derivation/capabilities'
 
 export {
     WH,
@@ -453,7 +475,7 @@ export {
     isValidWormholePair,
 } from './derivation/wormhole'
 
-export {rollupGatherer, rollupCrafter, rollupLoaders} from './derivation/rollups'
+export {rollupGatherer, rollupCrafter, rollupBuilder, rollupLoaders} from './derivation/rollups'
 
 export {resolveItem} from './resolution/resolve-item'
 export type {
@@ -518,6 +540,11 @@ export {
     ATOMICASSETS_ACCOUNT,
     SHIPLOAD_COLLECTION,
 } from './nft/atomicassets'
+export {
+    MODULE_STAT_SCALING_ANCHOR,
+    MODULE_STAT_SCALING_POST_ANCHOR_PERCENT,
+    computeEffectiveModuleStat,
+} from './derivation/stat-scaling'
 export type {
     AtomicAssetRow,
     AtomicSchemaRow,
@@ -534,6 +561,7 @@ export {
     computeBaseHullmass,
     computeBaseCapacityShip,
     computeBaseCapacityWarehouse,
+    computeBaseCapacityContainer,
     computeEngineThrust,
     computeEngineDrain,
     computeTravelDrain,
@@ -549,6 +577,8 @@ export {
     computeLoaderThrust,
     computeCrafterSpeed,
     computeCrafterDrain,
+    computeBuilderSpeed,
+    computeBuilderDrain,
     computeHaulerCapacity,
     computeHaulerEfficiency,
     computeWarpRange,

package/src/managers/actions.ts

@@ -1,12 +1,12 @@
 import {
     Action,
+    Bytes,
     Checksum256,
     type Checksum256Type,
     Int64,
     type Int64Type,
     Name,
     type NameType,
-    Transaction,
     UInt8,
     type UInt8Type,
     UInt16,
@@ -21,7 +21,6 @@ import {Coordinates, PRECISION, type ClusterSlotType, type CoordinatesType} from
 import {ServerContract} from '../contracts'
 import {ATOMICASSETS_ABI, SHIPLOAD_COLLECTION} from '../nft/atomicassets'
 import {getItem} from '../data/catalog'
-import type {GatherPlan} from '../planner'
 
 const CHARGE_K = 1n
 const ENERGY_DIVISOR = 1_000_000n
@@ -162,6 +161,8 @@ export type EntityRefInput = {
     entityId: UInt64Type
 }
 
+export type WaypointInput = {x: Int64Type; y: Int64Type}
+
 export class ActionsManager extends BaseManager {
     travel(shipId: UInt64Type, destination: CoordinatesType, recharge = true): Action {
         const x = Int64.from(destination.x)
@@ -197,6 +198,18 @@ export class ActionsManager extends BaseManager {
         })
     }
 
+    travelplan(entities: EntityRefInput[], waypoints: WaypointInput[], recharge = true): Action {
+        const entityRefs = this.entityRefs(entities)
+        const wps = waypoints.map((w) =>
+            ServerContract.Types.route_waypoint.from({x: Int64.from(w.x), y: Int64.from(w.y)})
+        )
+        return this.server.action('travelplan', {
+            entities: entityRefs,
+            waypoints: wps,
+            recharge,
+        })
+    }
+
     transit(shipId: UInt64Type, entrance: CoordinatesType, exit: CoordinatesType): Action {
         return this.server.action('transit', {
             id: UInt64.from(shipId),
@@ -302,6 +315,20 @@ export class ActionsManager extends BaseManager {
         })
     }
 
+    shuttle(
+        carrierId: UInt64Type,
+        fromId: UInt64Type,
+        toId: UInt64Type,
+        items: ServerContract.ActionParams.Type.cargo_item[]
+    ): Action {
+        return this.server.action('shuttle', {
+            carrier: UInt64.from(carrierId),
+            from_id: UInt64.from(fromId),
+            to_id: UInt64.from(toId),
+            items,
+        })
+    }
+
     launch(
         launcherId: UInt64Type,
         catcherId: UInt64Type,
@@ -374,48 +401,22 @@ export class ActionsManager extends BaseManager {
         return this.server.action('gather', params)
     }
 
-    // Packs N gather actions into one Transaction; the wallet/session fills in TAPoS at sign time.
-    bundleGather(
-        gathers: {
-            sourceId: UInt64Type
-            destinationId: UInt64Type
-            stratum: UInt16Type
-            quantity: UInt32Type
-            slot?: UInt8Type
-        }[]
-    ): Transaction {
-        const actions = gathers.map(({sourceId, destinationId, stratum, quantity, slot}) =>
-            this.gather(sourceId, destinationId, stratum, quantity, slot)
-        )
-        return Transaction.from({
-            expiration: 0,
-            ref_block_num: 0,
-            ref_block_prefix: 0,
-            actions,
-        })
-    }
-
-    // Mirrors the contract's projected_energy walk: recharge (if due) then gathers, per cycle.
-    flattenGatherPlan(
-        plan: GatherPlan,
-        ctx: {sourceId: UInt64Type; destinationId: UInt64Type; stratum: UInt16Type}
-    ): Action[] {
-        const actions: Action[] = []
-        for (const cycle of plan.cycles) {
-            if (cycle.rechargeBefore) actions.push(this.recharge(ctx.sourceId))
-            for (const limpet of cycle.limpets) {
-                actions.push(
-                    this.gather(
-                        ctx.sourceId,
-                        ctx.destinationId,
-                        ctx.stratum,
-                        limpet.quantity,
-                        limpet.slot
-                    )
-                )
-            }
-        }
-        return actions
+    gatherplan(
+        sourceId: UInt64Type,
+        destinationId: UInt64Type,
+        stratum: UInt16Type,
+        quantity: UInt32Type,
+        recharge = true,
+        slots: number[] = []
+    ): Action {
+        return this.server.action('gatherplan', {
+            source_id: UInt64.from(sourceId),
+            destination_id: UInt64.from(destinationId),
+            stratum: UInt16.from(stratum),
+            quantity: UInt32.from(quantity),
+            recharge,
+            slots: Bytes.from(slots),
+        })
     }
 
     warp(entityId: UInt64Type, destination: CoordinatesType): Action {
@@ -452,6 +453,50 @@ export class ActionsManager extends BaseManager {
         return this.server.action('craft', params)
     }
 
+    craftjob(
+        shipId: UInt64Type,
+        workshopId: UInt64Type,
+        slot: UInt8Type,
+        recipeId: UInt16Type,
+        quantity: UInt32Type,
+        inputs: ServerContract.ActionParams.Type.cargo_item[]
+    ): Action {
+        const params: ServerContract.ActionParams.craftjob = {
+            ship_id: UInt64.from(shipId),
+            workshop_id: UInt64.from(workshopId),
+            slot: UInt8.from(slot),
+            recipe_id: UInt16.from(recipeId),
+            quantity: UInt32.from(quantity),
+            inputs,
+        }
+        return this.server.action('craftjob', params)
+    }
+
+    claimjob(jobId: UInt64Type, shipId: UInt64Type): Action {
+        const params: ServerContract.ActionParams.claimjob = {
+            job_id: UInt64.from(jobId),
+            ship_id: UInt64.from(shipId),
+        }
+        return this.server.action('claimjob', params)
+    }
+
+    canceljob(jobId: UInt64Type, shipId: UInt64Type): Action {
+        const params: ServerContract.ActionParams.canceljob = {
+            job_id: UInt64.from(jobId),
+            ship_id: UInt64.from(shipId),
+        }
+        return this.server.action('canceljob', params)
+    }
+
+    setsocket(workshopId: UInt64Type, slot: UInt8Type, open: boolean): Action {
+        const params: ServerContract.ActionParams.setsocket = {
+            workshop_id: UInt64.from(workshopId),
+            slot: UInt8.from(slot),
+            open,
+        }
+        return this.server.action('setsocket', params)
+    }
+
     blend(entityId: UInt64Type, inputs: ServerContract.ActionParams.Type.cargo_item[]): Action {
         return this.server.action('blend', {
             id: UInt64.from(entityId),

package/src/managers/construction-types.ts

@@ -6,7 +6,7 @@ import type {PlotProgress} from './plot'
 
 export type BuildState = 'initializing' | 'accepting' | 'ready' | 'scheduled' | 'finalizing'
 
-export type FinalizerCapability = 'crafter'
+export type FinalizerCapability = 'builder'
 
 export interface BuildableTarget {
     entityId: UInt64
@@ -49,7 +49,7 @@ export interface FinalizerEntityRef {
     entityType: Name
     name: string
     capability: FinalizerCapability
-    crafterSpeed: number
+    builderSpeed: number
     estimatedDuration: UInt32
 }
 

package/src/managers/construction.ts

@@ -3,7 +3,7 @@ import {BaseManager} from './base'
 import type {ServerContract} from '../contracts'
 import {PlotManager} from './plot'
 import {getItem} from '../data/catalog'
-import {calc_craft_duration} from '../capabilities/crafting'
+import {calc_build_duration} from '../capabilities/crafting'
 import {getLanes, getTasks} from '../scheduling/schedule'
 import {HoldKind, TaskType} from '../types'
 import type {
@@ -67,15 +67,15 @@ export class ConstructionManager extends BaseManager {
             if (!entity.owner.equals(target.ownerName)) continue
             if (entity.id.equals(target.entityId)) continue
             if (!coordsEqual(entity.coordinates, target.coordinates)) continue
-            const crafterLanes = entity.crafter_lanes ?? []
-            if (crafterLanes.length === 0) continue
-            const speed = crafterLanes.reduce((s, l) => s + Number(l.speed), 0)
+            const builderLanes = entity.builder_lanes ?? []
+            if (builderLanes.length === 0) continue
+            const speed = builderLanes.reduce((s, l) => s + Number(l.speed), 0)
             out.push({
                 entityId: entity.id,
                 entityType: entity.type,
                 name: entity.entity_name,
-                capability: 'crafter',
-                crafterSpeed: speed,
+                capability: 'builder',
+                builderSpeed: speed,
                 estimatedDuration: this.estimateFinalizeDuration(target, speed),
             })
         }
@@ -105,10 +105,10 @@ export class ConstructionManager extends BaseManager {
                 for (const task of lane.schedule.tasks) {
                     cumulativeSec += task.duration.toNumber()
                     if (!isPushTask(task)) continue
-                    if (!task.entitytarget) continue
+                    if (task.couplings.length === 0) continue
                     const projectedEndMs = startedMs + cumulativeSec * 1000
                     if (projectedEndMs < nowMs) continue
-                    const targetIdStr = task.entitytarget.entity_id.toString()
+                    const targetIdStr = task.couplings[0].counterpart.entity_id.toString()
                     const etaSeconds = Math.max(0, Math.round((projectedEndMs - nowMs) / 1000))
                     let perTarget = buckets.get(targetIdStr)
                     if (!perTarget) {
@@ -263,8 +263,8 @@ export class ConstructionManager extends BaseManager {
         return reservationsOf(source)
     }
 
-    estimateFinalizeDuration(target: BuildableTarget, crafterSpeed: number): UInt32 {
-        return calc_craft_duration(crafterSpeed, target.progress.massRequired)
+    estimateFinalizeDuration(target: BuildableTarget, builderSpeed: number): UInt32 {
+        return calc_build_duration(builderSpeed, target.progress.massRequired)
     }
 
     static isConstructionKind(kind: string): boolean {
@@ -370,8 +370,8 @@ function isPushTask(task: ServerContract.Types.task): boolean {
 function isBuildOfPlot(task: ServerContract.Types.task, plotId: UInt64): boolean {
     return (
         task.type.toNumber() === TaskType.BUILDPLOT &&
-        task.entitytarget !== undefined &&
-        task.entitytarget.entity_id.equals(plotId)
+        task.couplings.length > 0 &&
+        task.couplings[0].counterpart.entity_id.equals(plotId)
     )
 }
 
@@ -379,9 +379,9 @@ function reservationsOf(source: ServerContract.Types.entity_info): Reservation[]
     const out = new Map<string, Reservation>()
     for (const task of getTasks(source)) {
         if (!isPushTask(task)) continue
-        if (!task.entitytarget) continue
-        const targetType = task.entitytarget.entity_type
-        const targetId = task.entitytarget.entity_id
+        if (task.couplings.length === 0) continue
+        const targetType = task.couplings[0].counterpart.entity_type
+        const targetId = task.couplings[0].counterpart.entity_id
         for (const c of task.cargo) {
             const itemId = c.item_id.toNumber()
             const quantity = c.quantity.toNumber()

package/src/managers/plot.ts

@@ -100,7 +100,7 @@ export class PlotManager extends BaseManager {
             recipe,
             progress,
             finalizeAction: Name.from('buildplot'),
-            finalizerCapability: 'crafter',
+            finalizerCapability: 'builder',
             activeTask,
             scheduledBuild,
         }

package/src/nft/buildImmutableData.ts

@@ -3,6 +3,7 @@ import {getItem} from '../data/catalog'
 import {
     getModuleCapabilityType,
     MODULE_BATTERY,
+    MODULE_BUILDER,
     MODULE_CRAFTER,
     MODULE_ENGINE,
     MODULE_GATHERER,
@@ -13,11 +14,14 @@ import {
     MODULE_WARP,
 } from '../capabilities/modules'
 import {decodeStat, decodeCraftedItemStats} from '../derivation/crafting'
+import {computeEffectiveModuleStat} from '../derivation/stat-scaling'
 import {getStatDefinitions} from '../derivation/stats'
 import type {ResourceCategory} from '../types'
 import {Types as ServerTypes} from '../contracts/server'
 import {
     buildEntityDescription,
+    computeBuilderDrain,
+    computeBuilderSpeed,
     computeCrafterDrain,
     computeCrafterSpeed,
     computeEngineDrain,
@@ -28,6 +32,7 @@ import {
     computeGeneratorCap,
     computeGeneratorRech,
     computeCargoBayCapacity,
+    computeCargoBayDrain,
     computeBatteryBankCapacity,
     computeHaulerCapacity,
     computeHaulerDrain,
@@ -75,6 +80,10 @@ export function moduleSlotsForImmutable(
 
 const IMAGE_HOST_URL = 'https://item.shiploadgame.com/item'
 
+function toWholeEnergy(milli: number): number {
+    return Math.floor((milli + 500) / 1000)
+}
+
 function bytesToBase64Url(bytes: Uint8Array): string {
     let binary = ''
     for (let i = 0; i < bytes.byteLength; i++) binary += String.fromCharCode(bytes[i]!)
@@ -183,8 +192,14 @@ export function buildModuleImmutable(
             const thm = decodeStat(stats, 1)
             base.push({first: 'volatility', second: ['uint16', vol]})
             base.push({first: 'thermal', second: ['uint16', thm]})
-            base.push({first: 'thrust', second: ['uint32', computeEngineThrust(vol)]})
-            base.push({first: 'drain', second: ['uint16', computeEngineDrain(thm)]})
+            base.push({
+                first: 'thrust',
+                second: ['uint32', computeEngineThrust(computeEffectiveModuleStat(vol))],
+            })
+            base.push({
+                first: 'drain',
+                second: ['uint16', computeEngineDrain(computeEffectiveModuleStat(thm))],
+            })
             break
         }
         case MODULE_GENERATOR: {
@@ -192,8 +207,20 @@ export function buildModuleImmutable(
             const ref = decodeStat(stats, 1)
             base.push({first: 'resonance', second: ['uint16', res]})
             base.push({first: 'reflectivity', second: ['uint16', ref]})
-            base.push({first: 'capacity', second: ['uint16', computeGeneratorCap(res)]})
-            base.push({first: 'recharge', second: ['uint16', computeGeneratorRech(ref)]})
+            base.push({
+                first: 'capacity',
+                second: [
+                    'uint16',
+                    toWholeEnergy(computeGeneratorCap(computeEffectiveModuleStat(res))),
+                ],
+            })
+            base.push({
+                first: 'recharge',
+                second: [
+                    'uint16',
+                    toWholeEnergy(computeGeneratorRech(computeEffectiveModuleStat(ref))),
+                ],
+            })
             break
         }
         case MODULE_GATHERER: {
@@ -204,7 +231,10 @@ export function buildModuleImmutable(
             base.push({first: 'hardness', second: ['uint16', hrd]})
             base.push({first: 'saturation', second: ['uint16', sat]})
             base.push({first: 'yield', second: ['uint16', computeGathererYield(str)]})
-            base.push({first: 'drain', second: ['uint16', computeGathererDrain(sat)]})
+            base.push({
+                first: 'drain',
+                second: ['uint16', toWholeEnergy(computeGathererDrain(sat))],
+            })
             base.push({first: 'depth', second: ['uint16', computeGathererDepth(hrd, item.tier)]})
             break
         }
@@ -229,7 +259,16 @@ export function buildModuleImmutable(
             base.push({first: 'fineness', second: ['uint16', fin]})
             base.push({first: 'conductivity', second: ['uint16', con]})
             base.push({first: 'speed', second: ['uint16', computeCrafterSpeed(fin)]})
-            base.push({first: 'drain', second: ['uint16', computeCrafterDrain(con)]})
+            base.push({first: 'drain', second: ['uint16', toWholeEnergy(computeCrafterDrain(con))]})
+            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))]})
             break
         }
         case MODULE_STORAGE: {
@@ -243,7 +282,11 @@ export function buildModuleImmutable(
             base.push({first: 'cohesion', second: ['uint16', com]})
             base.push({
                 first: 'capacity',
-                second: ['uint32', computeCargoBayCapacity(str, den, hrd, com)],
+                second: ['uint32', computeCargoBayCapacity(str, den, hrd)],
+            })
+            base.push({
+                first: 'drain',
+                second: ['uint16', toWholeEnergy(computeCargoBayDrain(com, item.tier))],
             })
             break
         }
@@ -258,7 +301,7 @@ export function buildModuleImmutable(
             base.push({first: 'insulation', second: ['uint16', ins]})
             base.push({
                 first: 'capacity',
-                second: ['uint32', computeBatteryBankCapacity(vol, thm, pla, ins)],
+                second: ['uint32', toWholeEnergy(computeBatteryBankCapacity(vol, thm, pla, ins))],
             })
             break
         }
@@ -271,7 +314,10 @@ export function buildModuleImmutable(
             base.push({first: 'conductivity', second: ['uint16', con]})
             base.push({first: 'capacity', second: ['uint8', computeHaulerCapacity(res, item.tier)]})
             base.push({first: 'efficiency', second: ['uint16', computeHaulerEfficiency(pla)]})
-            base.push({first: 'drain', second: ['uint16', computeHaulerDrain(con)]})
+            base.push({
+                first: 'drain',
+                second: ['uint16', toWholeEnergy(computeHaulerDrain(con, item.tier))],
+            })
             break
         }
     }