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

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,
+                            })
+                        }
                     }
                 }
             }
@@ -152,25 +153,24 @@ export class ConstructionManager extends BaseManager {
         completesAt: number
         hasStarted: boolean
     } | null {
-        const schedule = plot.schedule
-        if (!schedule) return null
-        const tasks = schedule.tasks
-        const startedMs = schedule.started.toDate().getTime()
-        let startSec = 0
-        for (const task of 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(),
+        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()
             }
-            startSec += task.duration.toNumber()
         }
         return null
     }
@@ -179,19 +179,22 @@ export class ConstructionManager extends BaseManager {
         builder: ServerContract.Types.entity_info | undefined,
         group: UInt64 | undefined
     ): {cancelable: boolean; blockingTaskCount: number} {
-        if (!builder?.schedule || group === undefined) {
+        if (!builder || group === undefined) {
             return {cancelable: false, blockingTaskCount: 0}
         }
-        const tasks = builder.schedule.tasks
-        const buildIdx = tasks.findIndex(
-            (t) =>
-                t.type.toNumber() === TaskType.BUILDPLOT &&
-                t.entitygroup !== undefined &&
-                t.entitygroup.equals(group)
-        )
-        if (buildIdx < 0) return {cancelable: false, blockingTaskCount: 0}
-        const trailing = tasks.length - 1 - buildIdx
-        return {cancelable: trailing === 0, blockingTaskCount: trailing}
+        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(
@@ -357,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)
 }

package/src/scheduling/availability.ts

@@ -0,0 +1,108 @@
+import type {ServerContract} from '../contracts'
+import {TaskType} from '../types'
+import * as schedule from './schedule'
+
+type Task = ServerContract.Types.task
+type CargoItem = ServerContract.Types.cargo_item
+
+export interface CargoEffect {
+    added: CargoItem[]
+    removed: CargoItem[]
+}
+
+export interface AvailabilityInput extends schedule.ScheduleData {
+    cargo: CargoItem[]
+}
+
+export function taskCargoEffect(task: Task): CargoEffect {
+    switch (task.type.toNumber()) {
+        case TaskType.LOAD:
+        case TaskType.UNWRAP:
+        case TaskType.UNDEPLOY:
+            return {added: task.cargo, removed: []}
+        case TaskType.UNLOAD:
+            return {added: [], removed: task.cargo}
+        case TaskType.GATHER:
+            return task.entitytarget ? {added: [], removed: []} : {added: task.cargo, removed: []}
+        case TaskType.CRAFT:
+            if (task.cargo.length === 0) return {added: [], removed: []}
+            return {added: [task.cargo[task.cargo.length - 1]], removed: task.cargo.slice(0, -1)}
+        case TaskType.DEPLOY:
+            return task.cargo.length > 0
+                ? {added: [], removed: [task.cargo[0]]}
+                : {added: [], removed: []}
+        default:
+            return {added: [], removed: []}
+    }
+}
+
+function cargoKey(item: CargoItem): string {
+    const base = `${item.item_id.toNumber()}:${item.stats.toString()}`
+    const modules = item.modules ?? []
+    const entityId = item.entity_id?.toString()
+    const normalizedEntityId = entityId && entityId !== '0' ? entityId : ''
+    if (modules.length === 0 && normalizedEntityId === '') return base
+    return `${base}:modules=${JSON.stringify(modules)}:entity=${normalizedEntityId}`
+}
+
+function cargoQuantity(item: CargoItem): bigint {
+    return BigInt(item.quantity.toString())
+}
+
+export function projectedCargoAvailableAt(
+    entity: AvailabilityInput,
+    at: Date
+): Map<string, bigint> {
+    const avail = new Map<string, bigint>()
+
+    for (const item of entity.cargo) {
+        const key = cargoKey(item)
+        avail.set(key, (avail.get(key) ?? 0n) + cargoQuantity(item))
+    }
+
+    // Every scheduled task reserves inputs against the unsettled cargo base, even already-elapsed ones.
+    const tasks = schedule.orderedTasks(entity)
+
+    for (const ordered of tasks) {
+        if (ordered.completesAt.getTime() >= at.getTime()) continue
+
+        for (const item of taskCargoEffect(ordered.task).added) {
+            const key = cargoKey(item)
+            avail.set(key, (avail.get(key) ?? 0n) + cargoQuantity(item))
+        }
+    }
+
+    for (const ordered of tasks) {
+        for (const item of taskCargoEffect(ordered.task).removed) {
+            const key = cargoKey(item)
+            const current = avail.get(key) ?? 0n
+            const quantity = cargoQuantity(item)
+            avail.set(key, current > quantity ? current - quantity : 0n)
+        }
+    }
+
+    return avail
+}
+
+// Latest completion among scheduled tasks producing any of the given inputs (a craft starts no earlier).
+export function cargoReadyAt(entity: AvailabilityInput, inputItemIds: readonly number[]): Date {
+    let readyMs = 0
+    for (const ordered of schedule.orderedTasks(entity)) {
+        for (const item of taskCargoEffect(ordered.task).added) {
+            if (inputItemIds.includes(item.item_id.toNumber())) {
+                readyMs = Math.max(readyMs, ordered.completesAt.getTime())
+                break
+            }
+        }
+    }
+    return new Date(readyMs)
+}
+
+export function availableForItem(avail: Map<string, bigint>, itemId: number): bigint {
+    const prefix = `${itemId}:`
+    let total = 0n
+    for (const [key, quantity] of avail) {
+        if (key.startsWith(prefix)) total += quantity
+    }
+    return total
+}

package/src/scheduling/energy.ts

@@ -1,6 +1,6 @@
 import {TaskType} from '../types'
 import {createProjectedEntity, type Projectable} from './projection'
-import {currentTaskIndex, currentTaskProgressFloat, isTaskComplete} from './schedule'
+import {orderedTasks} from './schedule'
 
 export function energyAtTime(entity: Projectable, now: Date): number {
     const projected = createProjectedEntity(entity)
@@ -13,24 +13,31 @@ export function energyAtTime(entity: Projectable, now: Date): number {
 
     let running = Number(projected.energy)
 
-    const tasks = entity.schedule?.tasks
-    if (!tasks || tasks.length === 0) return clamp(running)
+    const ordered = orderedTasks(entity)
+    if (ordered.length === 0) return clamp(running)
 
-    const activeIndex = currentTaskIndex(entity, now)
-    const activeProgress = currentTaskProgressFloat(entity, now)
+    const nowMs = now.getTime()
 
-    for (let i = 0; i < tasks.length; i++) {
-        const complete = isTaskComplete(entity, i, now)
-        if (!complete && i !== activeIndex) break
+    for (const {task, startsAt} of ordered) {
+        const duration = task.duration.toNumber()
+        const isReserved = task.type.toNumber() === TaskType.RESERVED
+        const elapsed = Math.min(
+            Math.max(0, Math.floor((nowMs - startsAt.getTime()) / 1000)),
+            duration
+        )
+        const complete = !isReserved && elapsed >= duration
+        const inProgress = !complete && elapsed > 0 && elapsed < duration
 
-        const fraction = complete ? 1 : activeProgress
+        if (!complete && !inProgress) continue
 
-        if (tasks[i].type.toNumber() === TaskType.RECHARGE) {
+        const fraction = complete ? 1 : duration === 0 ? 1 : elapsed / duration
+
+        if (task.type.toNumber() === TaskType.RECHARGE) {
             if (capacity !== undefined) {
                 running = complete ? capacity : running + (capacity - running) * fraction
             }
         } else {
-            const cost = Number(tasks[i].energy_cost ?? 0)
+            const cost = Number(task.energy_cost ?? 0)
             running -= cost * fraction
         }
 

package/src/scheduling/lane-core.ts

@@ -0,0 +1,130 @@
+import type {ServerContract} from '../contracts'
+import {TaskType} from '../types'
+
+type Schedule = ServerContract.Types.schedule
+type Task = ServerContract.Types.task
+
+export function laneDuration(schedule: Schedule): number {
+    return schedule.tasks.reduce((sum, task) => sum + task.duration.toNumber(), 0)
+}
+
+export function laneRawElapsed(schedule: Schedule, now: Date): number {
+    const started = schedule.started.toDate()
+    return Math.floor((now.getTime() - started.getTime()) / 1000)
+}
+
+export function laneElapsed(schedule: Schedule, now: Date): number {
+    return Math.max(0, laneRawElapsed(schedule, now))
+}
+
+export function laneStartsIn(schedule: Schedule, now: Date): number {
+    return Math.max(0, -laneRawElapsed(schedule, now))
+}
+
+export function laneRemaining(schedule: Schedule, now: Date): number {
+    return Math.max(0, laneDuration(schedule) - laneRawElapsed(schedule, now))
+}
+
+export function laneComplete(schedule: Schedule, now: Date): boolean {
+    if (schedule.tasks.length === 0) return false
+    if (schedule.tasks.some((t) => t.type.toNumber() === TaskType.RESERVED)) return false
+    return laneRemaining(schedule, now) === 0
+}
+
+export function laneProgress(schedule: Schedule, now: Date): number {
+    const duration = laneDuration(schedule)
+    if (duration === 0) return schedule.tasks.length > 0 ? 1 : 0
+    return Math.min(1, laneElapsed(schedule, now) / duration)
+}
+
+export function currentTaskIndexForLane(schedule: Schedule, now: Date): number {
+    if (schedule.tasks.length === 0) return -1
+    if (laneRawElapsed(schedule, now) < 0) return -1
+    const elapsed = laneElapsed(schedule, now)
+    let timeAccum = 0
+    for (let i = 0; i < schedule.tasks.length; i++) {
+        const taskDuration = schedule.tasks[i].duration.toNumber()
+        if (elapsed < timeAccum + taskDuration) return i
+        timeAccum += taskDuration
+    }
+    return -1
+}
+
+export function currentTask(schedule: Schedule, now: Date): Task | undefined {
+    const index = currentTaskIndexForLane(schedule, now)
+    if (index < 0) return undefined
+    return schedule.tasks[index]
+}
+
+export function currentTaskType(schedule: Schedule, now: Date): TaskType | undefined {
+    const task = currentTask(schedule, now)
+    return task ? (task.type.toNumber() as TaskType) : undefined
+}
+
+export function laneTaskStartTime(schedule: Schedule, index: number): number {
+    if (index < 0 || index >= schedule.tasks.length) return 0
+    let timeAccum = 0
+    for (let i = 0; i < index; i++) {
+        timeAccum += schedule.tasks[i].duration.toNumber()
+    }
+    return timeAccum
+}
+
+export function laneTaskElapsed(schedule: Schedule, index: number, now: Date): number {
+    if (index < 0 || index >= schedule.tasks.length) return 0
+    const elapsed = laneElapsed(schedule, now)
+    const taskStart = laneTaskStartTime(schedule, index)
+    const taskDuration = schedule.tasks[index].duration.toNumber()
+    if (elapsed <= taskStart) return 0
+    return Math.min(elapsed - taskStart, taskDuration)
+}
+
+export function laneTaskRemaining(schedule: Schedule, index: number, now: Date): number {
+    if (index < 0 || index >= schedule.tasks.length) return 0
+    const taskDuration = schedule.tasks[index].duration.toNumber()
+    return Math.max(0, taskDuration - laneTaskElapsed(schedule, index, now))
+}
+
+export function laneTaskComplete(schedule: Schedule, index: number, now: Date): boolean {
+    if (index < 0 || index >= schedule.tasks.length) return false
+    if (schedule.tasks[index].type.toNumber() === TaskType.RESERVED) return false
+    const taskDuration = schedule.tasks[index].duration.toNumber()
+    return laneTaskElapsed(schedule, index, now) >= taskDuration
+}
+
+export function laneTaskInProgress(schedule: Schedule, index: number, now: Date): boolean {
+    if (index < 0 || index >= schedule.tasks.length) return false
+    const taskElapsed = laneTaskElapsed(schedule, index, now)
+    const taskDuration = schedule.tasks[index].duration.toNumber()
+    return taskElapsed > 0 && taskElapsed < taskDuration
+}
+
+export function laneCompletesAt(schedule: Schedule, index: number): Date {
+    const startedMs = schedule.started.toDate().getTime()
+    const endSec =
+        laneTaskStartTime(schedule, index) + (schedule.tasks[index]?.duration.toNumber() ?? 0)
+    return new Date(startedMs + endSec * 1000)
+}
+
+export function currentTaskProgress(schedule: Schedule, now: Date): number {
+    const index = currentTaskIndexForLane(schedule, now)
+    if (index < 0) return 0
+    const elapsed = laneTaskElapsed(schedule, index, now)
+    const duration = schedule.tasks[index].duration.toNumber()
+    if (duration === 0) return 1
+    return Math.min(1, elapsed / duration)
+}
+
+export function currentTaskProgressFloatForLane(schedule: Schedule, now: Date): number {
+    if (schedule.tasks.length === 0) return 0
+    const index = currentTaskIndexForLane(schedule, now)
+    if (index < 0) return 0
+    const task = schedule.tasks[index]
+    const durationMs = task.duration.toNumber() * 1000
+    if (durationMs === 0) return 1
+    const startedMs = schedule.started.toDate().getTime()
+    const taskStartMs = startedMs + laneTaskStartTime(schedule, index) * 1000
+    const elapsedMs = now.getTime() - taskStartMs
+    if (elapsedMs <= 0) return 0
+    return Math.min(1, elapsedMs / durationMs)
+}