@shipload/sdk 1.0.0-next.20 → 1.0.0-next.22

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@shipload/sdk",
     "description": "SDKs for Shipload",
-    "version": "1.0.0-next.20",
+    "version": "1.0.0-next.22",
     "homepage": "https://github.com/shipload/toolkit/tree/master/packages/sdk",
     "repository": {
         "type": "git",

package/src/index-module.ts

@@ -59,6 +59,8 @@ export type {
     SourceCargoStack,
     FinalizerEntityRef,
     FinalizerCapability,
+    InboundTransfer,
+    Reservation,
 } from './managers'
 export type {EntityRefInput} from './managers/actions'
 
@@ -202,6 +204,8 @@ export type {
 export {taskCargoChanges} from './scheduling/task-cargo'
 export type {TaskCargoChange, TaskCargoDirection} from './scheduling/task-cargo'
 
+export {energyAtTime} from './scheduling/energy'
+
 export * from './types/capabilities'
 export * from './types/entity'
 export {

package/src/managers/construction-types.ts

@@ -32,10 +32,15 @@ export interface SourceEntityRef {
 }
 
 export interface SourceCargoStack {
+    key: string
+    rowId: UInt64
     itemId: number
     item: Item
+    stats: UInt64
+    modules: ServerContract.Types.module_entry[]
     available: number
     plotNeeds: number
+    reserved: number
 }
 
 export interface FinalizerEntityRef {
@@ -45,3 +50,19 @@ export interface FinalizerEntityRef {
     crafterSpeed: number
     estimatedDuration: UInt32
 }
+
+export interface InboundTransfer {
+    sourceEntityId: UInt64
+    sourceEntityType: Name
+    sourceName: string
+    itemId: number
+    quantity: number
+    etaSeconds: number
+}
+
+export interface Reservation {
+    targetEntityId: UInt64
+    targetEntityType: Name
+    itemId: number
+    quantity: number
+}

package/src/managers/construction.ts

@@ -1,12 +1,15 @@
-import type {UInt32} from '@wharfkit/antelope'
+import type {UInt64, UInt32} from '@wharfkit/antelope'
 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 {TaskType} from '../types'
 import type {
     BuildableTarget,
     FinalizerEntityRef,
+    InboundTransfer,
+    Reservation,
     SourceCargoStack,
     SourceEntityRef,
 } from './construction-types'
@@ -74,6 +77,78 @@ export class ConstructionManager extends BaseManager {
         return out.sort((a, b) => a.estimatedDuration.value - b.estimatedDuration.value)
     }
 
+    inboundTransfersTo(
+        plotId: UInt64,
+        entities: ServerContract.Types.entity_info[],
+        now: Date
+    ): InboundTransfer[] {
+        return this.inboundTransfersByTarget(entities, now).get(plotId.toString()) ?? []
+    }
+
+    inboundTransfersByTarget(
+        entities: ServerContract.Types.entity_info[],
+        now: Date
+    ): Map<string, InboundTransfer[]> {
+        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,
+                        })
+                    }
+                }
+            }
+        }
+        const out = new Map<string, InboundTransfer[]>()
+        for (const [targetId, perTarget] of buckets) {
+            out.set(targetId, Array.from(perTarget.values()))
+        }
+        return out
+    }
+
+    reservationsFrom(
+        sourceEntityId: UInt64,
+        entities: ServerContract.Types.entity_info[]
+    ): Reservation[] {
+        const source = entities.find((e) => e.id.equals(sourceEntityId))
+        if (!source) return []
+        return reservationsOf(source)
+    }
+
     estimateFinalizeDuration(target: BuildableTarget, crafterSpeed: number): UInt32 {
         return calc_craft_duration(crafterSpeed, target.progress.massRequired)
     }
@@ -90,28 +165,54 @@ function coordsEqual(
     return a.x.equals(b.x) && a.y.equals(b.y)
 }
 
+function moduleKey(module: ServerContract.Types.module_entry): string {
+    const installed = module.installed
+    if (!installed) return `${module.type.toNumber()}:empty`
+
+    return `${module.type.toNumber()}:${installed.item_id.toNumber()}:${installed.stats.toString()}`
+}
+
+function sourceStackKey(cargo: ServerContract.Types.cargo_row): string {
+    return `${cargo.item_id.toNumber()}#${cargo.stats.toString()}#${(cargo.modules ?? [])
+        .map(moduleKey)
+        .join(',')}`
+}
+
 function matchRelevantCargo(
     entity: ServerContract.Types.entity_info,
     target: BuildableTarget,
-    cargo: ServerContract.Types.cargo_row[]
+    cargo: ServerContract.Types.cargo_row[],
+    reservedByItem: Map<number, number>
 ): SourceCargoStack[] {
-    const quantityByItemId = new Map<number, number>()
+    const needsByItemId = new Map(
+        target.progress.rows.filter((row) => row.missing > 0).map((row) => [row.itemId, row])
+    )
+    const remainingReserved = new Map(reservedByItem)
+    const out: SourceCargoStack[] = []
     for (const c of cargo) {
         if (!c.entity_id.equals(entity.id)) continue
-        const id = c.item_id.toNumber()
-        quantityByItemId.set(id, (quantityByItemId.get(id) ?? 0) + c.quantity.toNumber())
-    }
-
-    const out: SourceCargoStack[] = []
-    for (const row of target.progress.rows) {
-        if (row.missing === 0) continue
-        const available = quantityByItemId.get(row.itemId) ?? 0
+        const itemId = c.item_id.toNumber()
+        const need = needsByItemId.get(itemId)
+        if (!need) continue
+        const gross = c.quantity.toNumber()
+        if (gross === 0) continue
+        const reservedRemaining = remainingReserved.get(itemId) ?? 0
+        const reserved = Math.min(gross, reservedRemaining)
+        const available = gross - reserved
+        if (reserved > 0) {
+            remainingReserved.set(itemId, reservedRemaining - reserved)
+        }
         if (available === 0) continue
         out.push({
-            itemId: row.itemId,
-            item: getItem(row.itemId),
+            key: sourceStackKey(c),
+            rowId: c.id,
+            itemId,
+            item: getItem(itemId),
+            stats: c.stats,
+            modules: c.modules ?? [],
             available,
-            plotNeeds: row.missing,
+            plotNeeds: need.missing,
+            reserved,
         })
     }
     return out
@@ -128,7 +229,8 @@ function partitionSources(
         if (!entity.owner.equals(target.ownerName)) continue
         if (entity.id.equals(target.entityId)) continue
         if (!coordsEqual(entity.coordinates, target.coordinates)) continue
-        const relevant = matchRelevantCargo(entity, target, cargo)
+        const reserved = reservedByItemFor(entity)
+        const relevant = matchRelevantCargo(entity, target, cargo, reserved)
         if (relevant.length === 0) continue
         const loaderCount = entity.loaders?.quantity.toNumber() ?? 0
         const loaderTotalMass = entity.loaders?.mass.toNumber() ?? 0
@@ -145,3 +247,45 @@ 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 reservationsOf(source: ServerContract.Types.entity_info): Reservation[] {
+    if (!source.schedule) return []
+    const out = new Map<string, Reservation>()
+    for (const task of source.schedule.tasks) {
+        if (!isTransferTask(task)) continue
+        if (!task.entitytarget) continue
+        const targetType = task.entitytarget.entity_type
+        const targetId = task.entitytarget.entity_id
+        for (const c of task.cargo) {
+            const itemId = c.item_id.toNumber()
+            const quantity = c.quantity.toNumber()
+            if (quantity === 0) continue
+            const key = `${targetId.toString()}#${itemId}`
+            const existing = out.get(key)
+            if (existing) {
+                existing.quantity += quantity
+            } else {
+                out.set(key, {
+                    targetEntityId: targetId,
+                    targetEntityType: targetType,
+                    itemId,
+                    quantity,
+                })
+            }
+        }
+    }
+    return Array.from(out.values())
+}
+
+function reservedByItemFor(source: ServerContract.Types.entity_info): Map<number, number> {
+    const out = new Map<number, number>()
+    for (const r of reservationsOf(source)) {
+        out.set(r.itemId, (out.get(r.itemId) ?? 0) + r.quantity)
+    }
+    return out
+}

package/src/managers/index.ts

@@ -19,4 +19,6 @@ export type {
     SourceCargoStack,
     FinalizerEntityRef,
     FinalizerCapability,
+    InboundTransfer,
+    Reservation,
 } from './construction-types'

package/src/scheduling/energy.ts

@@ -0,0 +1,41 @@
+import {TaskType} from '../types'
+import {createProjectedEntity, type Projectable} from './projection'
+import {currentTaskIndex, currentTaskProgressFloat, isTaskComplete} from './schedule'
+
+export function energyAtTime(entity: Projectable, now: Date): number {
+    const projected = createProjectedEntity(entity)
+    const capacity = projected.generator ? Number(projected.generator.capacity) : undefined
+
+    const clamp = (value: number): number => {
+        const floored = Math.max(0, value)
+        return capacity !== undefined ? Math.min(capacity, floored) : floored
+    }
+
+    let running = Number(projected.energy)
+
+    const tasks = entity.schedule?.tasks
+    if (!tasks || tasks.length === 0) return clamp(running)
+
+    const activeIndex = currentTaskIndex(entity, now)
+    const activeProgress = currentTaskProgressFloat(entity, now)
+
+    for (let i = 0; i < tasks.length; i++) {
+        const complete = isTaskComplete(entity, i, now)
+        if (!complete && i !== activeIndex) break
+
+        const fraction = complete ? 1 : activeProgress
+
+        if (tasks[i].type.toNumber() === TaskType.RECHARGE) {
+            if (capacity !== undefined) {
+                running = complete ? capacity : running + (capacity - running) * fraction
+            }
+        } else {
+            const cost = Number(tasks[i].energy_cost ?? 0)
+            running -= cost * fraction
+        }
+
+        running = clamp(running)
+    }
+
+    return clamp(running)
+}

package/src/scheduling/projection.ts

@@ -1,6 +1,6 @@
 import {Name, TimePoint, UInt16, UInt32, UInt64} from '@wharfkit/antelope'
 import {ServerContract} from '../contracts'
-import {Coordinates, PRECISION, TaskType} from '../types'
+import {Coordinates, TaskType} from '../types'
 import {
     capsHasLoaders,
     capsHasMovement,
@@ -20,7 +20,7 @@ import {getEntityLayout, getRecipe, type RecipeInput} from '../data/recipes-runt
 import {computeEntityCapabilities} from '../derivation/capabilities'
 import {decodeCraftedItemStats} from '../derivation/crafting'
 import {packedModulesToInstalled, type InstalledModule} from '../entities/slot-multiplier'
-import {distanceBetweenCoordinates, lerp} from '../travel/travel'
+import {lerp} from '../travel/travel'
 import {
     calcStacksMass,
     cargoItemToStack,
@@ -217,25 +217,22 @@ function applyFlightTask(
     task: ServerContract.Types.task,
     options: {complete: boolean; progress?: number}
 ): void {
-    if (!task.coordinates || !projected.engines) return
+    if (!task.coordinates) return
 
-    const origin = projected.location
     const destination = Coordinates.from(task.coordinates)
-    const distance = distanceBetweenCoordinates(origin, task.coordinates)
-    const energyUsage = distance.dividing(PRECISION).multiplying(projected.engines.drain)
 
     if (options.complete) {
-        projected.energy = projected.energy.gt(energyUsage)
-            ? UInt16.from(projected.energy.subtracting(energyUsage))
-            : UInt16.from(0)
+        applyEnergyCost(projected, task)
         projected.location = destination
     } else if (options.progress !== undefined) {
-        const interpolated = lerp(origin, destination, options.progress)
+        const interpolated = lerp(projected.location, destination, options.progress)
         projected.location = Coordinates.from({
             x: Math.round(interpolated.x),
             y: Math.round(interpolated.y),
         })
-        const partialEnergy = UInt64.from(Math.floor(Number(energyUsage) * options.progress))
+        const partialEnergy = UInt64.from(
+            Math.floor(Number(task.energy_cost ?? 0) * options.progress)
+        )
         projected.energy = projected.energy.gt(partialEnergy)
             ? UInt16.from(projected.energy.subtracting(partialEnergy))
             : UInt16.from(0)
@@ -305,6 +302,7 @@ function applyTask(projected: ProjectedEntity, task: ServerContract.Types.task):
             applyRechargeTask(projected, task, {complete: true})
             break
         case TaskType.TRAVEL:
+        case TaskType.WARP:
             applyFlightTask(projected, task, {complete: true})
             break
         case TaskType.LOAD:
@@ -479,6 +477,7 @@ export function projectEntityAt(entity: Projectable, now: Date): ProjectedEntity
                 applyRechargeTask(projected, task, {complete: taskComplete, progress})
                 break
             case TaskType.TRAVEL:
+            case TaskType.WARP:
                 applyFlightTask(projected, task, {complete: taskComplete, progress})
                 break
             case TaskType.LOAD: