@shipload/sdk 1.0.0-next.31 → 1.0.0-next.32

package/src/managers/construction.ts

@@ -5,7 +5,7 @@ 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 {HoldKind, TaskType} from '../types'
 import type {
     BuildableTarget,
     FinalizerEntityRef,
@@ -102,7 +102,7 @@ export class ConstructionManager extends BaseManager {
                 let cumulativeSec = 0
                 for (const task of lane.schedule.tasks) {
                     cumulativeSec += task.duration.toNumber()
-                    if (!isTransferTask(task)) continue
+                    if (!isPushTask(task)) continue
                     if (!task.entitytarget) continue
                     const projectedEndMs = startedMs + cumulativeSec * 1000
                     if (projectedEndMs < nowMs) continue
@@ -145,51 +145,53 @@ export class ConstructionManager extends BaseManager {
 
     private plotReservation(
         plot: ServerContract.Types.entity_info,
+        builder: ServerContract.Types.entity_info | undefined,
         now: Date
     ): {
         builderId: UInt64
-        group?: UInt64
         startsAt: number
         completesAt: number
         hasStarted: boolean
     } | null {
-        for (const lane of getLanes(plot)) {
+        const hold = plot.holds.find((h) => h.kind.toNumber() === HoldKind.BUILD)
+        if (!hold) return null
+        const builderId = hold.counterpart.entity_id
+        const completesAt = hold.until.toDate().getTime()
+        const startsAt = this.builderBuildStart(builder, plot.id) ?? completesAt
+        return {
+            builderId,
+            startsAt,
+            completesAt,
+            hasStarted: startsAt <= now.getTime(),
+        }
+    }
+
+    private builderBuildStart(
+        builder: ServerContract.Types.entity_info | undefined,
+        plotId: UInt64
+    ): number | undefined {
+        if (!builder) return undefined
+        for (const lane of getLanes(builder)) {
             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(),
-                    }
-                }
+                if (isBuildOfPlot(task, plotId)) return startedMs + startSec * 1000
                 startSec += task.duration.toNumber()
             }
         }
-        return null
+        return undefined
     }
 
     private builderCancelability(
         builder: ServerContract.Types.entity_info | undefined,
-        group: UInt64 | undefined
+        plotId: UInt64
     ): {cancelable: boolean; blockingTaskCount: number} {
-        if (!builder || group === undefined) {
+        if (!builder) {
             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)
-            )
+            const buildIdx = tasks.findIndex((t) => isBuildOfPlot(t, plotId))
             if (buildIdx < 0) continue
             const trailing = tasks.length - 1 - buildIdx
             return {cancelable: trailing === 0, blockingTaskCount: trailing}
@@ -200,14 +202,14 @@ export class ConstructionManager extends BaseManager {
     private buildFromReservation(
         res: {
             builderId: UInt64
-            group?: UInt64
             startsAt: number
             completesAt: number
             hasStarted: boolean
         },
+        plotId: UInt64,
         builder: ServerContract.Types.entity_info | undefined
     ): ScheduledBuild {
-        const {cancelable, blockingTaskCount} = this.builderCancelability(builder, res.group)
+        const {cancelable, blockingTaskCount} = this.builderCancelability(builder, plotId)
         return {
             shipId: res.builderId,
             shipName: builder?.entity_name || res.builderId.toString(),
@@ -224,10 +226,12 @@ export class ConstructionManager extends BaseManager {
         entities: ServerContract.Types.entity_info[],
         now: Date
     ): ScheduledBuild | null {
-        const res = this.plotReservation(plot, now)
+        const hold = plot.holds.find((h) => h.kind.toNumber() === HoldKind.BUILD)
+        if (!hold) return null
+        const builder = entities.find((e) => e.id.equals(hold.counterpart.entity_id))
+        const res = this.plotReservation(plot, builder, now)
         if (!res) return null
-        const builder = entities.find((e) => e.id.equals(res.builderId))
-        return this.buildFromReservation(res, builder)
+        return this.buildFromReservation(res, plot.id, builder)
     }
 
     scheduledBuildsByTarget(
@@ -238,10 +242,12 @@ export class ConstructionManager extends BaseManager {
         const out = new Map<string, ScheduledBuild>()
         for (const entity of entities) {
             if (entity.type.toString() !== 'plot') continue
-            const res = this.plotReservation(entity, now)
+            const hold = entity.holds.find((h) => h.kind.toNumber() === HoldKind.BUILD)
+            if (!hold) continue
+            const builder = byId.get(hold.counterpart.entity_id.toString())
+            const res = this.plotReservation(entity, builder, now)
             if (!res) continue
-            const builder = byId.get(res.builderId.toString())
-            out.set(entity.id.toString(), this.buildFromReservation(res, builder))
+            out.set(entity.id.toString(), this.buildFromReservation(res, entity.id, builder))
         }
         return out
     }
@@ -354,15 +360,22 @@ function partitionSources(
     return {eligible, unreachable}
 }
 
-function isTransferTask(task: ServerContract.Types.task): boolean {
-    const type = task.type.toNumber()
-    return type === TaskType.LOAD || type === TaskType.UNLOAD
+function isPushTask(task: ServerContract.Types.task): boolean {
+    return task.type.toNumber() === TaskType.UNLOAD
+}
+
+function isBuildOfPlot(task: ServerContract.Types.task, plotId: UInt64): boolean {
+    return (
+        task.type.toNumber() === TaskType.BUILDPLOT &&
+        task.entitytarget !== undefined &&
+        task.entitytarget.entity_id.equals(plotId)
+    )
 }
 
 function reservationsOf(source: ServerContract.Types.entity_info): Reservation[] {
     const out = new Map<string, Reservation>()
     for (const task of getTasks(source)) {
-        if (!isTransferTask(task)) continue
+        if (!isPushTask(task)) continue
         if (!task.entitytarget) continue
         const targetType = task.entitytarget.entity_type
         const targetId = task.entitytarget.entity_id

package/src/scheduling/energy.ts

@@ -20,12 +20,11 @@ export function energyAtTime(entity: Projectable, now: Date): number {
 
     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 complete = elapsed >= duration
         const inProgress = !complete && elapsed > 0 && elapsed < duration
 
         if (!complete && !inProgress) continue

package/src/scheduling/idle-resolve.ts

@@ -0,0 +1,44 @@
+import type {Action, UInt64} from '@wharfkit/antelope'
+import type {ServerContract} from '../contracts'
+import type {ActionsManager} from '../managers/actions'
+import {hasResolvable, type ScheduleData} from './schedule'
+
+type EntityInfo = ServerContract.Types.entity_info
+
+export type CounterpartLookup = (entityId: UInt64) => EntityInfo | undefined
+
+export type IdleResolveTarget = ScheduleData & {id: UInt64}
+
+// A hold's driving task lives on its counterpart, so a hold resolves the counterpart, never the blocker.
+export function composeIdleResolve(
+    blocker: IdleResolveTarget,
+    action: Action,
+    actions: ActionsManager,
+    now: Date,
+    lookupCounterpart?: CounterpartLookup
+): Action[] {
+    const ids: UInt64[] = []
+    const seen = new Set<string>()
+
+    const add = (id: UInt64) => {
+        const key = id.toString()
+        if (seen.has(key)) return
+        seen.add(key)
+        ids.push(id)
+    }
+
+    if (hasResolvable(blocker, now)) {
+        add(blocker.id)
+    }
+
+    for (const hold of blocker.holds ?? []) {
+        const counterpartId = hold.counterpart.entity_id
+        if (lookupCounterpart) {
+            const counterpart = lookupCounterpart(counterpartId)
+            if (!counterpart || !hasResolvable(counterpart, now)) continue
+        }
+        add(counterpartId)
+    }
+
+    return [...ids.map((id) => actions.resolve(id)), action]
+}

package/src/scheduling/lane-core.ts

@@ -1,5 +1,5 @@
 import type {ServerContract} from '../contracts'
-import {TaskType} from '../types'
+import type {TaskType} from '../types'
 
 type Schedule = ServerContract.Types.schedule
 type Task = ServerContract.Types.task
@@ -27,7 +27,6 @@ export function laneRemaining(schedule: Schedule, now: Date): number {
 
 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
 }
 
@@ -87,7 +86,6 @@ export function laneTaskRemaining(schedule: Schedule, index: number, now: Date):
 
 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
 }

package/src/scheduling/projection.ts

@@ -442,12 +442,11 @@ export function projectEntityAt(entity: Projectable, now: Date): ProjectedEntity
 
     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 taskComplete = !isReserved && elapsed >= duration
+        const taskComplete = elapsed >= duration
         const taskInProgress = elapsed > 0 && elapsed < duration
 
         if (!taskComplete && !taskInProgress) {

package/src/scheduling/schedule.ts

@@ -5,12 +5,14 @@ import * as core from './lane-core'
 type Schedule = ServerContract.Types.schedule
 type Task = ServerContract.Types.task
 type Lane = ServerContract.Types.lane
+type Hold = ServerContract.Types.hold
 
 export const LANE_MOBILITY = 0
 export const LANE_BARRIER = 255
 
 export interface ScheduleData {
     lanes?: Lane[]
+    holds?: Hold[]
 }
 
 export interface LaneView {
@@ -52,11 +54,17 @@ export function hasSchedule(entity: ScheduleData): boolean {
     return lanes.some((l) => l.schedule.tasks.length > 0)
 }
 
+export function hasHolds(entity: ScheduleData): boolean {
+    const holds = entity.holds
+    return !!holds && holds.length > 0
+}
+
 export function isIdle(entity: ScheduleData): boolean {
-    return !hasSchedule(entity)
+    return !hasSchedule(entity) && !hasHolds(entity)
 }
 
 export function isEntityIdle(entity: ScheduleData, now: Date): boolean {
+    if (hasHolds(entity)) return false
     const lanes = entity.lanes
     if (!lanes) return true
     return lanes.every((l) => core.currentTaskIndexForLane(l.schedule, now) < 0)
@@ -106,13 +114,7 @@ export function scheduleComplete(entity: ScheduleData, now: Date): boolean {
     let hasAnyTask = false
     let remaining = 0
     for (const l of lanes) {
-        const tasks = l.schedule.tasks
-        if (tasks.length > 0) {
-            hasAnyTask = true
-            for (const t of tasks) {
-                if (t.type.toNumber() === TaskType.RESERVED) return false
-            }
-        }
+        if (l.schedule.tasks.length > 0) hasAnyTask = true
         remaining = Math.max(remaining, core.laneRemaining(l.schedule, now))
     }
     if (!hasAnyTask) return false
@@ -186,7 +188,6 @@ export function resolveOrder(entity: ScheduleData, now: Date): ResolvedEvent[] {
             const task = l.schedule.tasks[i]
             endSec += task.duration.toNumber()
             const completesAt = new Date(startedMs + endSec * 1000)
-            if (task.type.toNumber() === TaskType.RESERVED) break
             if (completesAt.getTime() > now.getTime()) break
             events.push({laneKey, taskIndex: i, task, completesAt})
         }

package/src/subscriptions/mappers.ts

@@ -19,5 +19,7 @@ export function parseWireEntity(raw: WireEntity): ServerContract.Types.entity_in
     }
     delete shaped.name
 
+    if (shaped.holds === undefined) shaped.holds = []
+
     return ServerContract.Types.entity_info.from(shaped)
 }

package/src/types.ts

@@ -56,7 +56,13 @@ export enum TaskType {
     DEMOLISH = 13,
     CLAIMPLOT = 14,
     BUILDPLOT = 15,
-    RESERVED = 16,
+}
+
+export enum HoldKind {
+    PULL = 1,
+    PUSH = 2,
+    GATHER = 3,
+    BUILD = 4,
 }
 
 export enum LocationType {