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

package/src/scheduling/lanes.ts

@@ -1,12 +1,47 @@
 import type {ServerContract} from '../contracts'
 import {getItem} from '../data/catalog'
+import {getEntityLayout} from '../data/recipes-runtime'
+import {decodeStat} from '../derivation/crafting'
+import {gathererDepthForTier} from '../derivation/capabilities'
+import {applySlotMultiplier, getSlotAmp} from '../entities/slot-multiplier'
+import {
+    computeGathererYield,
+    computeGathererDrain,
+    computeLoaderThrust,
+    computeLoaderMass,
+    computeCrafterSpeed,
+    computeCrafterDrain,
+} from '../nft/description'
 import type {ModuleType} from '../types'
-import {getLane, type ScheduleData} from './schedule'
+import {getLane, LANE_MOBILITY, type ScheduleData} from './schedule'
 
 type ModuleEntry = ServerContract.Types.module_entry
 type Lane = ServerContract.Types.lane
 type Schedule = ServerContract.Types.schedule
 
+export interface ResolvedGathererLane {
+    slotIndex: number
+    yield: number
+    drain: number
+    depth: number
+    outputPct: number
+}
+
+export interface ResolvedCrafterLane {
+    slotIndex: number
+    speed: number
+    drain: number
+    outputPct: number
+}
+
+export interface ResolvedLoaderLane {
+    slotIndex: number
+    thrust: number
+    mass: number
+    outputPct: number
+    valid: boolean
+}
+
 export function laneKeyForModule(slotIndex: number): number {
     return slotIndex + 1
 }
@@ -16,11 +51,114 @@ function laneIsFree(lanes: Lane[], laneKey: number): boolean {
     return lane ? lane.schedule.tasks.length === 0 : true
 }
 
+export function resolveLaneGatherer(
+    modules: ModuleEntry[],
+    entityItemId: number,
+    laneKey: number
+): ResolvedGathererLane {
+    const idx = laneKey - 1
+    const installed = idx >= 0 && idx < modules.length ? modules[idx].installed : undefined
+    if (!installed) throw new Error('gatherer lane has no module')
+    const item = getItem(Number(installed.item_id.value ?? installed.item_id))
+    if (item.moduleType !== 'gatherer') throw new Error('lane module is not a gatherer')
+    const stats = BigInt(installed.stats.toString())
+    const str = decodeStat(stats, 0)
+    const tol = decodeStat(stats, 1)
+    const con = decodeStat(stats, 2)
+    const layout = getEntityLayout(entityItemId)?.slots ?? []
+    const amp = getSlotAmp(layout, idx)
+    const yieldVal = applySlotMultiplier(computeGathererYield(str), amp)
+    const drain = computeGathererDrain(con)
+    const depth = gathererDepthForTier(tol, item.tier ?? 1)
+    return {slotIndex: idx, yield: yieldVal, drain, depth, outputPct: amp}
+}
+
+// Encapsulates the gather handler's lane selection (gathering.cpp:108-112): both error paths.
+export function selectGatherLane(
+    modules: ModuleEntry[],
+    entityItemId: number,
+    lanes: Lane[],
+    stratum: number,
+    explicitSlot?: number
+): number {
+    if (explicitSlot !== undefined) {
+        const laneKey = laneKeyForModule(explicitSlot)
+        const lane = resolveLaneGatherer(modules, entityItemId, laneKey)
+        if (stratum > lane.depth) throw new Error('stratum exceeds gatherer depth')
+        return laneKey
+    }
+    return workerLaneKey(modules, 'gatherer', lanes, stratum)
+}
+
+export function resolveLaneCrafter(
+    modules: ModuleEntry[],
+    entityItemId: number,
+    laneKey: number
+): ResolvedCrafterLane {
+    const idx = laneKey - 1
+    const installed = idx >= 0 && idx < modules.length ? modules[idx].installed : undefined
+    if (!installed) throw new Error('crafter lane has no module')
+    const item = getItem(Number(installed.item_id.value ?? installed.item_id))
+    if (item.moduleType !== 'crafter') throw new Error('lane module is not a crafter')
+    const stats = BigInt(installed.stats.toString())
+    const rea = decodeStat(stats, 0)
+    const fin = decodeStat(stats, 1)
+    const layout = getEntityLayout(entityItemId)?.slots ?? []
+    const amp = getSlotAmp(layout, idx)
+    const speed = applySlotMultiplier(computeCrafterSpeed(rea), amp)
+    const drain = computeCrafterDrain(fin)
+    return {slotIndex: idx, speed, drain, outputPct: amp}
+}
+
+// LANE_MOBILITY or a missing module soft-returns valid=false (never throws); callers check `valid`.
+export function resolveLaneLoader(
+    modules: ModuleEntry[],
+    entityItemId: number,
+    laneKey: number
+): ResolvedLoaderLane {
+    if (laneKey === LANE_MOBILITY) {
+        return {slotIndex: -1, thrust: 0, mass: 0, outputPct: 0, valid: false}
+    }
+    const idx = laneKey - 1
+    const installed = idx >= 0 && idx < modules.length ? modules[idx].installed : undefined
+    if (!installed) {
+        return {slotIndex: idx, thrust: 0, mass: 0, outputPct: 0, valid: false}
+    }
+    const stats = BigInt(installed.stats.toString())
+    const ins = decodeStat(stats, 0)
+    const pla = decodeStat(stats, 1)
+    const layout = getEntityLayout(entityItemId)?.slots ?? []
+    const amp = getSlotAmp(layout, idx)
+    const thrust = applySlotMultiplier(computeLoaderThrust(pla), amp)
+    const mass = computeLoaderMass(ins)
+    return {slotIndex: idx, thrust, mass, outputPct: amp, valid: true}
+}
+
 export function workerLaneKey(
     modules: ModuleEntry[],
     moduleSubtype: ModuleType,
-    lanes: Lane[]
+    lanes: Lane[],
+    stratum?: number
 ): number {
+    if (moduleSubtype === 'gatherer' && stratum !== undefined) {
+        let lowestReaching: number | undefined
+        for (let i = 0; i < modules.length; i++) {
+            const installed = modules[i].installed
+            if (!installed) continue
+            const item = getItem(Number(installed.item_id.value ?? installed.item_id))
+            if (item.moduleType !== 'gatherer') continue
+            const stats = BigInt(installed.stats.toString())
+            const tol = decodeStat(stats, 1)
+            const depth = gathererDepthForTier(tol, item.tier ?? 1)
+            if (depth < stratum) continue
+            const laneKey = laneKeyForModule(i)
+            if (lowestReaching === undefined) lowestReaching = laneKey
+            if (laneIsFree(lanes, laneKey)) return laneKey
+        }
+        if (lowestReaching === undefined) throw new Error('no gatherer reaches this stratum')
+        return lowestReaching
+    }
+
     const occupiedMatchingLaneKeys: number[] = []
 
     for (let slotIndex = 0; slotIndex < modules.length; slotIndex++) {

package/src/scheduling/projection.ts

@@ -2,7 +2,6 @@ import {Name, UInt16, UInt32, UInt64} from '@wharfkit/antelope'
 import {ServerContract} from '../contracts'
 import {Coordinates, TaskType} from '../types'
 import {
-    capsHasLoaders,
     capsHasMovement,
     capsHasStorage,
     type EntityCapabilities,
@@ -18,7 +17,7 @@ import {
 } from '../errors'
 import {getEntityLayout, getRecipe, type RecipeInput} from '../data/recipes-runtime'
 import {computeEntityCapabilities} from '../derivation/capabilities'
-import {decodeCraftedItemStats} from '../derivation/crafting'
+import {decodeCraftedItemStats, decodeStat} from '../derivation/crafting'
 import {packedModulesToInstalled, type InstalledModule} from '../entities/slot-multiplier'
 import {lerp} from '../travel/travel'
 import {
@@ -39,11 +38,13 @@ export interface ProjectedEntity {
     shipMass: UInt32
     capacity?: UInt64
     engines?: ServerContract.Types.movement_stats
-    loaders?: ServerContract.Types.loader_stats
+    loaderLanes: ServerContract.Types.loader_lane[]
     generator?: ServerContract.Types.energy_stats
     hauler?: ServerContract.Types.hauler_stats
     readonly cargoMass: UInt64
     readonly totalMass: UInt64
+    readonly gathererLanes: ServerContract.Types.gatherer_lane[]
+    readonly crafterLanes: ServerContract.Types.crafter_lane[]
 
     hasMovement(): boolean
     hasStorage(): boolean
@@ -59,7 +60,9 @@ export interface Projectable extends ScheduleData {
     hullmass?: UInt32
     generator?: ServerContract.Types.energy_stats
     engines?: ServerContract.Types.movement_stats
-    loaders?: ServerContract.Types.loader_stats
+    loader_lanes?: ServerContract.Types.loader_lane[]
+    gatherer_lanes?: ServerContract.Types.gatherer_lane[]
+    crafter_lanes?: ServerContract.Types.crafter_lane[]
     hauler?: ServerContract.Types.hauler_stats
     capacity?: UInt32
     cargo: ServerContract.Types.cargo_item[]
@@ -84,7 +87,9 @@ interface ProjectedCaps {
     capacity?: UInt32
     engines?: ServerContract.Types.movement_stats
     generator?: ServerContract.Types.energy_stats
-    loaders?: ServerContract.Types.loader_stats
+    loaderLanes: ServerContract.Types.loader_lane[]
+    gathererLanes: ServerContract.Types.gatherer_lane[]
+    crafterLanes: ServerContract.Types.crafter_lane[]
     hauler?: ServerContract.Types.hauler_stats
 }
 
@@ -101,10 +106,53 @@ function recomputeCaps(entity: Projectable): ProjectedCaps | undefined {
         typeof entity.item_id === 'number' ? entity.item_id : entity.item_id.value
     )
     const hullStats = decodeCraftedItemStats(itemId, entity.stats)
+    if (hullStats.strength === undefined) hullStats.strength = decodeStat(entity.stats, 0)
+    if (hullStats.hardness === undefined) hullStats.hardness = decodeStat(entity.stats, 2)
     const layout = getEntityLayout(itemId)?.slots ?? []
     const installed = toInstalledModules(entity.modules)
     const caps = computeEntityCapabilities(hullStats, itemId, installed, layout)
 
+    const toLoaderLane = (l: {
+        slotIndex: number
+        mass: number
+        thrust: number
+        outputPct: number
+    }): ServerContract.Types.loader_lane =>
+        ServerContract.Types.loader_lane.from({
+            slot_index: l.slotIndex,
+            mass: l.mass,
+            thrust: l.thrust,
+            output_pct: l.outputPct,
+        })
+
+    const toGathererLane = (l: {
+        slotIndex: number
+        yield: number
+        drain: number
+        depth: number
+        outputPct: number
+    }): ServerContract.Types.gatherer_lane =>
+        ServerContract.Types.gatherer_lane.from({
+            slot_index: l.slotIndex,
+            yield: l.yield,
+            drain: l.drain,
+            depth: l.depth,
+            output_pct: l.outputPct,
+        })
+
+    const toCrafterLane = (l: {
+        slotIndex: number
+        speed: number
+        drain: number
+        outputPct: number
+    }): ServerContract.Types.crafter_lane =>
+        ServerContract.Types.crafter_lane.from({
+            slot_index: l.slotIndex,
+            speed: l.speed,
+            drain: l.drain,
+            output_pct: l.outputPct,
+        })
+
     return {
         hullmass: UInt32.from(caps.hullmass),
         capacity: UInt32.from(caps.capacity),
@@ -112,15 +160,23 @@ function recomputeCaps(entity: Projectable): ProjectedCaps | undefined {
         generator: caps.generator
             ? ServerContract.Types.energy_stats.from(caps.generator)
             : undefined,
-        loaders: caps.loaders ? ServerContract.Types.loader_stats.from(caps.loaders) : undefined,
+        loaderLanes: (caps.loaderLanes ?? []).map(toLoaderLane),
+        gathererLanes: (caps.gathererLanes ?? []).map(toGathererLane),
+        crafterLanes: (caps.crafterLanes ?? []).map(toCrafterLane),
         hauler: caps.hauler ? ServerContract.Types.hauler_stats.from(caps.hauler) : undefined,
     }
 }
 
+function loaderLanesTotalMass(lanes: ServerContract.Types.loader_lane[]): UInt64 {
+    let total = 0
+    for (const l of lanes) total += Number(l.mass)
+    return UInt64.from(total)
+}
+
 export function createProjectedEntity(entity: Projectable): ProjectedEntity {
     const needsRecompute =
         entity.hullmass === undefined ||
-        entity.loaders === undefined ||
+        entity.loader_lanes === undefined ||
         entity.engines === undefined ||
         entity.generator === undefined ||
         entity.hauler === undefined ||
@@ -128,7 +184,9 @@ export function createProjectedEntity(entity: Projectable): ProjectedEntity {
     const caps = needsRecompute ? recomputeCaps(entity) : undefined
 
     const shipMass = UInt32.from(entity.hullmass ?? caps?.hullmass ?? 0)
-    const loaders = entity.loaders ?? caps?.loaders
+    const loaderLanes = entity.loader_lanes ?? caps?.loaderLanes ?? []
+    const gathererLanes = entity.gatherer_lanes ?? caps?.gathererLanes ?? []
+    const crafterLanes = entity.crafter_lanes ?? caps?.crafterLanes ?? []
     const engines = entity.engines ?? caps?.engines
     const generator = entity.generator ?? caps?.generator
     const hauler = entity.hauler ?? caps?.hauler
@@ -145,18 +203,18 @@ export function createProjectedEntity(entity: Projectable): ProjectedEntity {
         engines,
         generator,
         hauler,
-        loaders,
+        loaderLanes,
+        gathererLanes,
+        crafterLanes,
 
         get cargoMass() {
             return calcStacksMass(this.cargo)
         },
 
         get totalMass() {
-            let mass = UInt64.from(this.shipMass).adding(this.cargoMass)
-            if (this.loaders) {
-                mass = mass.adding(this.loaders.mass.multiplying(this.loaders.quantity))
-            }
-            return mass
+            return UInt64.from(this.shipMass)
+                .adding(this.cargoMass)
+                .adding(loaderLanesTotalMass(this.loaderLanes))
         },
 
         hasMovement() {
@@ -168,7 +226,7 @@ export function createProjectedEntity(entity: Projectable): ProjectedEntity {
         },
 
         hasLoaders() {
-            return capsHasLoaders(this.capabilities())
+            return this.loaderLanes.length > 0
         },
 
         capabilities(): EntityCapabilities {
@@ -177,7 +235,6 @@ export function createProjectedEntity(entity: Projectable): ProjectedEntity {
                 capacity: this.capacity ? UInt32.from(this.capacity) : undefined,
                 engines: this.engines,
                 generator: this.generator,
-                loaders: this.loaders,
             }
         },
 

package/src/shipload.ts

@@ -7,6 +7,7 @@ import {GameContext} from './managers/context'
 import type {EntitiesManager} from './managers/entities'
 import type {PlayersManager} from './managers/players'
 import type {LocationsManager} from './managers/locations'
+import type {CoordinatesManager} from './managers/coordinates'
 import type {EpochsManager} from './managers/epochs'
 import type {ActionsManager} from './managers/actions'
 import type {NftManager} from './managers/nft'
@@ -110,6 +111,10 @@ export class Shipload {
         return this._context.locations
     }
 
+    get coordinates(): CoordinatesManager {
+        return this._context.coordinates
+    }
+
     get epochs(): EpochsManager {
         return this._context.epochs
     }

package/src/testing/projection-parity.ts

@@ -12,9 +12,11 @@ export interface ContractProjectedState {
     hullmass?: UInt32
     capacity?: UInt32
     engines?: ServerContract.Types.movement_stats
-    loaders?: ServerContract.Types.loader_stats
     generator?: ServerContract.Types.energy_stats
     hauler?: ServerContract.Types.hauler_stats
+    gatherer_lanes: ServerContract.Types.gatherer_lane[]
+    crafter_lanes: ServerContract.Types.crafter_lane[]
+    loader_lanes: ServerContract.Types.loader_lane[]
 }
 
 export interface ProjectionComparisonOptions {
@@ -55,10 +57,32 @@ export function assertProjectionEquals(
     record('capacity', toNum(contract.capacity), sdk.capacity ? Number(sdk.capacity) : undefined)
 
     recordStatBlock('engines', contract.engines, sdk.engines)
-    recordStatBlock('loaders', contract.loaders, sdk.loaders)
     recordStatBlock('generator', contract.generator, sdk.generator)
     recordStatBlock('hauler', contract.hauler, sdk.hauler)
 
+    const normLane = (l: {slot_index?: unknown; [k: string]: unknown}) =>
+        Object.fromEntries(
+            Object.entries(l)
+                .filter(([k]) => k !== 'slot_index')
+                .map(([k, v]) => [k, toNum(v) ?? 0])
+        )
+
+    const compareLanes = (name: string, cLanes: unknown[], sLanes: unknown[]) => {
+        if (cLanes.length !== sLanes.length) {
+            mismatches.push(`  ${name}.length: contract=${cLanes.length} sdk=${sLanes.length}`)
+            return
+        }
+        for (let i = 0; i < cLanes.length; i++) {
+            const cn = JSON.stringify(normLane(cLanes[i] as Record<string, unknown>))
+            const sn = JSON.stringify(normLane(sLanes[i] as Record<string, unknown>))
+            if (cn !== sn) mismatches.push(`  ${name}[${i}]: contract=${cn} sdk=${sn}`)
+        }
+    }
+
+    compareLanes('gatherer_lanes', contract.gatherer_lanes as unknown[], sdk.gathererLanes ?? [])
+    compareLanes('crafter_lanes', contract.crafter_lanes as unknown[], sdk.crafterLanes ?? [])
+    compareLanes('loader_lanes', contract.loader_lanes as unknown[], sdk.loaderLanes ?? [])
+
     if (contract.cargo.length > 0 || sdk.cargo.length > 0) {
         const contractCargo = normaliseCargo(mergeContractCargo(contract.cargo))
         const sdkCargo = normaliseCargo(sdk.cargo)