@shipload/sdk 1.0.0-next.25 → 1.0.0-next.27

package/src/derivation/capabilities.ts

@@ -55,7 +55,7 @@ export const GATHERER_DEPTH_TABLE: readonly GathererDepthParams[] = [
     {floor: 46000, slope: 12},
     {floor: 53500, slope: 10},
     {floor: 60000, slope: 5},
-    {floor: 63500, slope: 2},
+    {floor: 63537, slope: 2},
 ]
 
 export const GATHERER_DEPTH_MAX_TIER = 10
@@ -175,6 +175,7 @@ import {decodeCraftedItemStats} from './crafting'
 import {
     applySlotMultiplier,
     clampUint16,
+    clampUint32,
     getSlotAmp,
     type InstalledModule,
 } from '../entities/slot-multiplier'
@@ -346,8 +347,8 @@ export function computeEntityCapabilities(
     }
     if (hasGenerator) {
         result.generator = {
-            capacity: clampUint16(totalGenCapacity),
-            recharge: clampUint16(totalGenRecharge),
+            capacity: clampUint32(totalGenCapacity),
+            recharge: clampUint32(totalGenRecharge),
         }
     }
     if (hasGatherer) {

package/src/entities/entity.ts

@@ -28,7 +28,7 @@ export class Entity extends ServerContract.Types.entity_info {
     }
 
     get isIdle(): boolean {
-        return this.is_idle
+        return schedule.isIdle(this)
     }
 
     get sched(): ScheduleAccessor {

package/src/entities/makers.ts

@@ -11,6 +11,7 @@ import {getItem} from '../data/catalog'
 import {getModuleCapabilityType, moduleAccepts, moduleSlotTypeToCode} from '../capabilities/modules'
 import {computeEntityCapabilities} from '../derivation/capabilities'
 import {packedModulesToInstalled} from './slot-multiplier'
+import {LANE_MOBILITY} from '../scheduling/schedule'
 
 export interface PackedModuleInput {
     itemId: number
@@ -29,6 +30,7 @@ export interface EntityStateInput {
     energy?: number
     modules?: PackedModuleInput[]
     schedule?: ServerContract.Types.schedule
+    lanes?: ServerContract.Types.lane[]
     cargo?: ServerContract.Types.cargo_item[]
 }
 
@@ -86,6 +88,17 @@ export function makeEntity(packedItemId: number, state: EntityStateInput): Entit
     const layout = getEntityLayout(packedItemId)?.slots ?? []
     const mods = state.modules ?? []
 
+    const lanes =
+        state.lanes ??
+        (state.schedule
+            ? [
+                  ServerContract.Types.lane.from({
+                      lane_key: UInt8.from(LANE_MOBILITY),
+                      schedule: state.schedule,
+                  }),
+              ]
+            : [])
+
     const info: Record<string, unknown> = {
         type: template.kind,
         id: UInt64.from(state.id),
@@ -95,14 +108,10 @@ export function makeEntity(packedItemId: number, state: EntityStateInput): Entit
         item_id: UInt16.from(state.itemId ?? template.itemId),
         cargomass: UInt32.from(state.cargomass ?? 0),
         cargo: state.cargo || [],
-        is_idle: !state.schedule,
-        current_task_elapsed: UInt32.from(0),
-        current_task_remaining: UInt32.from(0),
-        pending_tasks: [],
+        lanes,
     }
 
     if (state.energy !== undefined) info.energy = UInt16.from(state.energy)
-    if (state.schedule) info.schedule = state.schedule
 
     if (kind === 'container') {
         info.modules = []

package/src/entities/slot-multiplier.ts

@@ -28,6 +28,8 @@ export function clampUint16(value: number): number {
     return Math.min(value, U16_MAX)
 }
 
+export const clampUint32 = (v: number): number => Math.min(Math.max(Math.floor(v), 0), 4294967295)
+
 export function applySlotMultiplier(value: number, outputPct: number): number {
     return clampUint16(Math.floor((value * outputPct) / 100))
 }

package/src/index-module.ts

@@ -28,6 +28,7 @@ export type movement_stats = ServerContract.Types.movement_stats
 export type energy_stats = ServerContract.Types.energy_stats
 export type loader_stats = ServerContract.Types.loader_stats
 export type schedule = ServerContract.Types.schedule
+export type lane = ServerContract.Types.lane
 export type task = ServerContract.Types.task
 export type cargo_item = ServerContract.Types.cargo_item
 export type entity_row = ServerContract.Types.entity_row
@@ -177,7 +178,19 @@ export type {
 } from './travel/travel'
 
 export * as schedule from './scheduling/schedule'
-export type {Scheduleable, ScheduleData} from './scheduling/schedule'
+export {LANE_MOBILITY, LANE_BARRIER} from './scheduling/schedule'
+export type {
+    ScheduleData,
+    LaneView,
+    OrderedTask,
+    ResolvedEvent,
+} from './scheduling/schedule'
+export {
+    candidateLaneCompletesAt,
+    laneKeyForModule,
+    rawScheduleEnd,
+    workerLaneKey,
+} from './scheduling/lanes'
 export {ScheduleAccessor, createScheduleAccessor} from './scheduling/accessor'
 export {InventoryAccessor, createInventoryAccessor} from './entities/inventory-accessor'
 export type {HasCargo} from './entities/inventory-accessor'
@@ -191,13 +204,11 @@ export {
     createProjectedEntity,
     projectEntity,
     projectEntityAt,
-    projectFromCurrentState,
-    projectFromCurrentStateAt,
+    projectRemainingAt,
     validateSchedule,
 } from './scheduling/projection'
 export type {
     Projectable,
-    ProjectableSnapshot,
     ProjectedEntity,
     ProjectionOptions,
 } from './scheduling/projection'
@@ -205,6 +216,15 @@ export type {
 export {taskCargoChanges} from './scheduling/task-cargo'
 export type {TaskCargoChange, TaskCargoDirection} from './scheduling/task-cargo'
 
+export {
+    projectedCargoAvailableAt,
+    availableForItem,
+    cargoReadyAt,
+    taskCargoEffect,
+} from './scheduling/availability'
+
+export {maxCraftable} from './capabilities/craftable'
+
 export {energyAtTime} from './scheduling/energy'
 
 export * from './types/capabilities'

package/src/managers/actions.ts

@@ -65,13 +65,22 @@ export class ActionsManager extends BaseManager {
         return this.server.action('resolve', params)
     }
 
-    cancel(entityId: UInt64Type, count: UInt64Type): Action {
+    cancel(entityId: UInt64Type, laneKey: number, count: UInt64Type): Action {
         return this.server.action('cancel', {
             id: UInt64.from(entityId),
+            lane_key: UInt8.from(laneKey),
             count: UInt64.from(count),
         })
     }
 
+    retarget(sourceId: UInt64Type, taskIndex: UInt64Type, newDestId: UInt64Type): Action {
+        return this.server.action('retarget', {
+            source_id: UInt64.from(sourceId),
+            task_index: UInt64.from(taskIndex),
+            new_dest_id: UInt64.from(newDestId),
+        })
+    }
+
     recharge(entityId: UInt64Type): Action {
         return this.server.action('recharge', {
             id: UInt64.from(entityId),
@@ -252,6 +261,12 @@ export class ActionsManager extends BaseManager {
         })
     }
 
+    claimStarter(owner: NameType): Action {
+        return this.server.action('claimstarter', {
+            owner: Name.from(owner),
+        })
+    }
+
     async wrapEntity(
         owner: NameType,
         entityId: UInt64Type,

package/src/managers/construction-types.ts

@@ -67,7 +67,8 @@ export interface ScheduledBuild {
     hasStarted: boolean
     startsAt: number
     completesAt: number
-    trailingCancelCount: number
+    cancelable: boolean
+    blockingTaskCount: number
 }
 
 export interface Reservation {

package/src/managers/construction.ts

@@ -4,6 +4,7 @@ import type {ServerContract} from '../contracts'
 import {PlotManager} from './plot'
 import {getItem} from '../data/catalog'
 import {calc_craft_duration} from '../capabilities/crafting'
+import {getLanes, getTasks} from '../scheduling/schedule'
 import {TaskType} from '../types'
 import type {
     BuildableTarget,
@@ -94,43 +95,43 @@ export class ConstructionManager extends BaseManager {
         const buckets = new Map<string, Map<string, InboundTransfer>>()
         const nowMs = now.getTime()
         for (const entity of entities) {
-            const schedule = entity.schedule
-            if (!schedule) continue
             const entityIdStr = entity.id.toString()
             const sourceName = entity.entity_name || entityIdStr
-            const startedMs = schedule.started.toDate().getTime()
-            let cumulativeSec = 0
-            for (const task of schedule.tasks) {
-                cumulativeSec += task.duration.toNumber()
-                if (!isTransferTask(task)) continue
-                if (!task.entitytarget) continue
-                const projectedEndMs = startedMs + cumulativeSec * 1000
-                if (projectedEndMs < nowMs) continue
-                const targetIdStr = task.entitytarget.entity_id.toString()
-                const etaSeconds = Math.max(0, Math.round((projectedEndMs - nowMs) / 1000))
-                let perTarget = buckets.get(targetIdStr)
-                if (!perTarget) {
-                    perTarget = new Map()
-                    buckets.set(targetIdStr, perTarget)
-                }
-                for (const c of task.cargo) {
-                    const itemId = c.item_id.toNumber()
-                    const quantity = c.quantity.toNumber()
-                    if (quantity === 0) continue
-                    const key = `${entityIdStr}#${itemId}`
-                    const existing = perTarget.get(key)
-                    if (existing) {
-                        existing.quantity += quantity
-                        existing.etaSeconds = Math.min(existing.etaSeconds, etaSeconds)
-                    } else {
-                        perTarget.set(key, {
-                            sourceEntityId: entity.id,
-                            sourceEntityType: entity.type,
-                            sourceName,
-                            itemId,
-                            quantity,
-                            etaSeconds,
-                        })
+            for (const lane of getLanes(entity)) {
+                const startedMs = lane.schedule.started.toDate().getTime()
+                let cumulativeSec = 0
+                for (const task of lane.schedule.tasks) {
+                    cumulativeSec += task.duration.toNumber()
+                    if (!isTransferTask(task)) continue
+                    if (!task.entitytarget) continue
+                    const projectedEndMs = startedMs + cumulativeSec * 1000
+                    if (projectedEndMs < nowMs) continue
+                    const targetIdStr = task.entitytarget.entity_id.toString()
+                    const etaSeconds = Math.max(0, Math.round((projectedEndMs - nowMs) / 1000))
+                    let perTarget = buckets.get(targetIdStr)
+                    if (!perTarget) {
+                        perTarget = new Map()
+                        buckets.set(targetIdStr, perTarget)
+                    }
+                    for (const c of task.cargo) {
+                        const itemId = c.item_id.toNumber()
+                        const quantity = c.quantity.toNumber()
+                        if (quantity === 0) continue
+                        const key = `${entityIdStr}#${itemId}`
+                        const existing = perTarget.get(key)
+                        if (existing) {
+                            existing.quantity += quantity
+                            existing.etaSeconds = Math.min(existing.etaSeconds, etaSeconds)
+                        } else {
+                            perTarget.set(key, {
+                                sourceEntityId: entity.id,
+                                sourceEntityType: entity.type,
+                                sourceName,
+                                itemId,
+                                quantity,
+                                etaSeconds,
+                            })
+                        }
                     }
                 }
             }
@@ -142,51 +143,107 @@ export class ConstructionManager extends BaseManager {
         return out
     }
 
+    private plotReservation(
+        plot: ServerContract.Types.entity_info,
+        now: Date
+    ): {
+        builderId: UInt64
+        group?: UInt64
+        startsAt: number
+        completesAt: number
+        hasStarted: boolean
+    } | null {
+        for (const lane of getLanes(plot)) {
+            const startedMs = lane.schedule.started.toDate().getTime()
+            let startSec = 0
+            for (const task of lane.schedule.tasks) {
+                if (task.type.toNumber() === TaskType.RESERVED) {
+                    if (!task.entitytarget) return null
+                    const startsAt = startedMs + startSec * 1000
+                    const completesAt = startsAt + task.duration.toNumber() * 1000
+                    return {
+                        builderId: task.entitytarget.entity_id,
+                        group: task.entitygroup ?? undefined,
+                        startsAt,
+                        completesAt,
+                        hasStarted: startsAt <= now.getTime(),
+                    }
+                }
+                startSec += task.duration.toNumber()
+            }
+        }
+        return null
+    }
+
+    private builderCancelability(
+        builder: ServerContract.Types.entity_info | undefined,
+        group: UInt64 | undefined
+    ): {cancelable: boolean; blockingTaskCount: number} {
+        if (!builder || group === undefined) {
+            return {cancelable: false, blockingTaskCount: 0}
+        }
+        for (const lane of getLanes(builder)) {
+            const tasks = lane.schedule.tasks
+            const buildIdx = tasks.findIndex(
+                (t) =>
+                    t.type.toNumber() === TaskType.BUILDPLOT &&
+                    t.entitygroup !== undefined &&
+                    t.entitygroup.equals(group)
+            )
+            if (buildIdx < 0) continue
+            const trailing = tasks.length - 1 - buildIdx
+            return {cancelable: trailing === 0, blockingTaskCount: trailing}
+        }
+        return {cancelable: false, blockingTaskCount: 0}
+    }
+
+    private buildFromReservation(
+        res: {
+            builderId: UInt64
+            group?: UInt64
+            startsAt: number
+            completesAt: number
+            hasStarted: boolean
+        },
+        builder: ServerContract.Types.entity_info | undefined
+    ): ScheduledBuild {
+        const {cancelable, blockingTaskCount} = this.builderCancelability(builder, res.group)
+        return {
+            shipId: res.builderId,
+            shipName: builder?.entity_name || res.builderId.toString(),
+            hasStarted: res.hasStarted,
+            startsAt: res.startsAt,
+            completesAt: res.completesAt,
+            cancelable,
+            blockingTaskCount,
+        }
+    }
+
     scheduledBuildFor(
-        plotId: UInt64,
+        plot: ServerContract.Types.entity_info,
         entities: ServerContract.Types.entity_info[],
         now: Date
     ): ScheduledBuild | null {
-        return this.scheduledBuildsByTarget(entities, now).get(plotId.toString()) ?? null
+        const res = this.plotReservation(plot, now)
+        if (!res) return null
+        const builder = entities.find((e) => e.id.equals(res.builderId))
+        return this.buildFromReservation(res, builder)
     }
 
     scheduledBuildsByTarget(
         entities: ServerContract.Types.entity_info[],
         now: Date
     ): Map<string, ScheduledBuild> {
-        const nowMs = now.getTime()
-        const best = new Map<string, ScheduledBuild>()
+        const byId = new Map(entities.map((e) => [e.id.toString(), e]))
+        const out = new Map<string, ScheduledBuild>()
         for (const entity of entities) {
-            const schedule = entity.schedule
-            if (!schedule) continue
-            const startedMs = schedule.started.toDate().getTime()
-            const tasks = schedule.tasks
-            let cumulativeSec = 0
-            for (let i = 0; i < tasks.length; i++) {
-                const task = tasks[i]
-                const startSec = cumulativeSec
-                cumulativeSec += task.duration.toNumber()
-                if (task.type.toNumber() !== TaskType.BUILDPLOT) continue
-                if (!task.entitytarget) continue
-                const completesAt = startedMs + cumulativeSec * 1000
-                if (completesAt < nowMs) continue
-                const startsAt = startedMs + startSec * 1000
-                const targetId = task.entitytarget.entity_id.toString()
-                const candidate: ScheduledBuild = {
-                    shipId: entity.id,
-                    shipName: entity.entity_name || entity.id.toString(),
-                    hasStarted: startsAt <= nowMs,
-                    startsAt,
-                    completesAt,
-                    trailingCancelCount: tasks.length - 1 - i,
-                }
-                const existing = best.get(targetId)
-                if (!existing || candidate.completesAt < existing.completesAt) {
-                    best.set(targetId, candidate)
-                }
-            }
+            if (entity.type.toString() !== 'plot') continue
+            const res = this.plotReservation(entity, now)
+            if (!res) continue
+            const builder = byId.get(res.builderId.toString())
+            out.set(entity.id.toString(), this.buildFromReservation(res, builder))
         }
-        return best
+        return out
     }
 
     reservationsFrom(
@@ -303,9 +360,8 @@ function isTransferTask(task: ServerContract.Types.task): boolean {
 }
 
 function reservationsOf(source: ServerContract.Types.entity_info): Reservation[] {
-    if (!source.schedule) return []
     const out = new Map<string, Reservation>()
-    for (const task of source.schedule.tasks) {
+    for (const task of getTasks(source)) {
         if (!isTransferTask(task)) continue
         if (!task.entitytarget) continue
         const targetType = task.entitytarget.entity_type

package/src/scheduling/accessor.ts

@@ -1,86 +1,128 @@
 import type {ServerContract} from '../contracts'
 import type {TaskType} from '../types'
-import type {ScheduleData} from './schedule'
-import * as schedule from './schedule'
+import * as core from './lane-core'
+import {
+    activeTasks,
+    getLane,
+    getLanes,
+    hasSchedule,
+    isIdle,
+    LANE_MOBILITY,
+    type LaneView,
+    type ScheduleData,
+} from './schedule'
 
 type Task = ServerContract.Types.task
 
 export class ScheduleAccessor {
-    constructor(private entity: ScheduleData) {}
+    private _laneResolved = false
+    private _lane: LaneView | undefined
+
+    constructor(
+        private entity: ScheduleData,
+        private laneKey: number = LANE_MOBILITY
+    ) {}
+
+    private get lane(): LaneView | undefined {
+        if (!this._laneResolved) {
+            this._lane = getLane(this.entity, this.laneKey)
+            this._laneResolved = true
+        }
+        return this._lane
+    }
+
+    forLane(laneKey: number): ScheduleAccessor {
+        return new ScheduleAccessor(this.entity, laneKey)
+    }
+
+    get lanes(): LaneView[] {
+        return getLanes(this.entity)
+    }
 
     get hasSchedule(): boolean {
-        return schedule.hasSchedule(this.entity)
+        return hasSchedule(this.entity)
     }
 
     get isIdle(): boolean {
-        return schedule.isIdle(this.entity)
+        return isIdle(this.entity)
     }
 
     get tasks(): Task[] {
-        return schedule.getTasks(this.entity)
+        return this.lane?.schedule.tasks ?? []
+    }
+
+    activeTasks(now: Date): Task[] {
+        return activeTasks(this.entity, now)
     }
 
     duration(): number {
-        return schedule.scheduleDuration(this.entity)
+        return this.lane ? core.laneDuration(this.lane.schedule) : 0
     }
 
     elapsed(now: Date): number {
-        return schedule.scheduleElapsed(this.entity, now)
+        return this.lane ? core.laneElapsed(this.lane.schedule, now) : 0
     }
 
     remaining(now: Date): number {
-        return schedule.scheduleRemaining(this.entity, now)
+        return this.lane ? core.laneRemaining(this.lane.schedule, now) : 0
+    }
+
+    startsIn(now: Date): number {
+        return this.lane ? core.laneStartsIn(this.lane.schedule, now) : 0
     }
 
     complete(now: Date): boolean {
-        return schedule.scheduleComplete(this.entity, now)
+        return this.lane ? core.laneComplete(this.lane.schedule, now) : false
     }
 
     currentTaskIndex(now: Date): number {
-        return schedule.currentTaskIndex(this.entity, now)
+        return this.lane ? core.currentTaskIndexForLane(this.lane.schedule, now) : -1
     }
 
     currentTask(now: Date): Task | undefined {
-        return schedule.currentTask(this.entity, now)
+        return this.lane ? core.currentTask(this.lane.schedule, now) : undefined
     }
 
     currentTaskType(now: Date): TaskType | undefined {
-        return schedule.currentTaskType(this.entity, now)
+        return this.lane ? core.currentTaskType(this.lane.schedule, now) : undefined
     }
 
     taskStartTime(index: number): number {
-        return schedule.getTaskStartTime(this.entity, index)
+        return this.lane ? core.laneTaskStartTime(this.lane.schedule, index) : 0
     }
 
     taskElapsed(index: number, now: Date): number {
-        return schedule.getTaskElapsed(this.entity, index, now)
+        return this.lane ? core.laneTaskElapsed(this.lane.schedule, index, now) : 0
     }
 
     taskRemaining(index: number, now: Date): number {
-        return schedule.getTaskRemaining(this.entity, index, now)
+        return this.lane ? core.laneTaskRemaining(this.lane.schedule, index, now) : 0
     }
 
     taskComplete(index: number, now: Date): boolean {
-        return schedule.isTaskComplete(this.entity, index, now)
+        return this.lane ? core.laneTaskComplete(this.lane.schedule, index, now) : false
     }
 
     taskInProgress(index: number, now: Date): boolean {
-        return schedule.isTaskInProgress(this.entity, index, now)
+        return this.lane ? core.laneTaskInProgress(this.lane.schedule, index, now) : false
     }
 
     currentTaskProgress(now: Date): number {
-        return schedule.currentTaskProgress(this.entity, now)
+        return this.lane ? core.currentTaskProgress(this.lane.schedule, now) : 0
     }
 
     currentTaskProgressFloat(now: Date): number {
-        return schedule.currentTaskProgressFloat(this.entity, now)
+        return this.lane ? core.currentTaskProgressFloatForLane(this.lane.schedule, now) : 0
     }
 
     progress(now: Date): number {
-        return schedule.scheduleProgress(this.entity, now)
+        return this.lane ? core.laneProgress(this.lane.schedule, now) : 0
     }
 }
 
-export function createScheduleAccessor(entity: ScheduleData): ScheduleAccessor {
-    return new ScheduleAccessor(entity)
+export function createScheduleAccessor(
+    entity: ScheduleData,
+    laneKey: number = LANE_MOBILITY
+): ScheduleAccessor {
+    return new ScheduleAccessor(entity, laneKey)
 }