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

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.21",
     "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'
 

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,79 @@ 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 targetIdStr = task.entitytarget.entity_id.toString()
+                const etaSeconds = Math.max(
+                    0,
+                    Math.round((startedMs + cumulativeSec * 1000 - 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 +166,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 +230,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 +248,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'