@shipload/sdk 1.0.0-next.67 → 1.0.0-next.68

package/package.json

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

package/src/influence/civic-shuttle.test.ts

@@ -72,7 +72,7 @@ function makeLane(laneKey: number, tasks: Task[]): Lane {
 
 test('civicShuttleBays lists both Depot bays with their queue depth', () => {
     const lanes = [makeLane(1, [shuttleTask(20, 21)])]
-    const bays = civicShuttleBays(depotModules(), ITEM_DEPOT_T1_PACKED, lanes)
+    const bays = civicShuttleBays(depotModules(), ITEM_DEPOT_T1_PACKED, lanes, T0)
     expect(bays.map((b) => b.laneKey)).toEqual([1, 2])
     expect(bays.map((b) => b.slotIndex)).toEqual([0, 1])
     expect(bays[0].queued).toBe(1)
@@ -83,25 +83,68 @@ test('civicShuttleBays lists both Depot bays with their queue depth', () => {
 
 test('a bay is full at the job queue cap', () => {
     const filled = Array.from({length: JOB_QUEUE_CAP}, () => shuttleTask(20, 21))
-    const bays = civicShuttleBays(depotModules(), ITEM_DEPOT_T1_PACKED, [makeLane(1, filled)])
+    const bays = civicShuttleBays(depotModules(), ITEM_DEPOT_T1_PACKED, [makeLane(1, filled)], T0)
     expect(bays[0].full).toBe(true)
     expect(bays[1].full).toBe(false)
 })
 
+const AFTER = new Date(T0.getTime() + 3_600_000)
+
+test('a landed booking leaves the bay free, since booking clears it', () => {
+    const filled = Array.from({length: JOB_QUEUE_CAP}, () => shuttleTask(20, 21))
+    const lanes = [makeLane(1, filled)]
+    const bays = civicShuttleBays(depotModules(), ITEM_DEPOT_T1_PACKED, lanes, AFTER)
+    expect(bays[0].queued).toBe(0)
+    expect(bays[0].full).toBe(false)
+    expect(selectCivicShuttleBay(depotModules(), ITEM_DEPOT_T1_PACKED, lanes, AFTER)?.laneKey).toBe(
+        1
+    )
+})
+
+test('a bay part-way through its queue counts only what is still unfinished', () => {
+    const lanes = [makeLane(1, [shuttleTask(20, 21), shuttleTask(22, 23), shuttleTask(24, 25)])]
+    const bays = civicShuttleBays(
+        depotModules(),
+        ITEM_DEPOT_T1_PACKED,
+        lanes,
+        new Date(T0.getTime() + 90_000)
+    )
+    expect(bays[0].queued).toBe(2)
+})
+
+test('a landed transfer is listed for settling but is not callable', () => {
+    const lanes = [makeLane(1, [shuttleTask(20, 21)])]
+    const [transfer] = pendingCivicTransfers({lanes} as never, AFTER)
+    expect(transfer.isTail).toBe(true)
+    expect(transfer.complete).toBe(true)
+    expect(transfer.callable).toBe(false)
+})
+
+test('landed transfers do not count against the per-player cap', () => {
+    const mine = Array.from({length: CIVIC_TRANSFER_PER_PLAYER_CAP}, (_, i) =>
+        shuttleTask(20 + i, 50)
+    )
+    const senderIds = mine.map((_, i) => 20 + i)
+    const at = {lanes: [makeLane(1, mine)]} as never
+    expect(civicTransfersAtCap(at, senderIds, T0)).toBe(true)
+    expect(civicTransfersAtCap(at, senderIds, AFTER)).toBe(false)
+    expect(civicTransfersFrom(at, senderIds, AFTER).length).toBe(CIVIC_TRANSFER_PER_PLAYER_CAP)
+})
+
 test('selectCivicShuttleBay takes the first free bay, then the lowest occupied one', () => {
     const modules = depotModules()
-    expect(selectCivicShuttleBay(modules, ITEM_DEPOT_T1_PACKED, [])?.laneKey).toBe(1)
+    expect(selectCivicShuttleBay(modules, ITEM_DEPOT_T1_PACKED, [], T0)?.laneKey).toBe(1)
 
     const firstBusy = [makeLane(1, [shuttleTask(20, 21)])]
-    expect(selectCivicShuttleBay(modules, ITEM_DEPOT_T1_PACKED, firstBusy)?.laneKey).toBe(2)
+    expect(selectCivicShuttleBay(modules, ITEM_DEPOT_T1_PACKED, firstBusy, T0)?.laneKey).toBe(2)
 
     const bothBusy = [makeLane(1, [shuttleTask(20, 21)]), makeLane(2, [shuttleTask(22, 23)])]
-    expect(selectCivicShuttleBay(modules, ITEM_DEPOT_T1_PACKED, bothBusy)?.laneKey).toBe(1)
+    expect(selectCivicShuttleBay(modules, ITEM_DEPOT_T1_PACKED, bothBusy, T0)?.laneKey).toBe(1)
 })
 
 test('selectCivicShuttleBay returns nothing when the building has no loaders', () => {
     const modules = [makeModuleEntry(ITEM_STORAGE_T1, storageStats)]
-    expect(selectCivicShuttleBay(modules, ITEM_DEPOT_T1_PACKED, [])).toBeUndefined()
+    expect(selectCivicShuttleBay(modules, ITEM_DEPOT_T1_PACKED, [], T0)).toBeUndefined()
 })
 
 test('pendingCivicTransfers reports the bay, both counterparties, and the tail', () => {
@@ -109,7 +152,7 @@ test('pendingCivicTransfers reports the bay, both counterparties, and the tail',
         makeLane(1, [shuttleTask(20, 21), shuttleTask(22, 23)]),
         makeLane(2, [shuttleTask(24, 25)]),
     ]
-    const transfers = pendingCivicTransfers({lanes} as never)
+    const transfers = pendingCivicTransfers({lanes} as never, T0)
     expect(transfers.length).toBe(3)
 
     const first = transfers.find((t) => String(t.senderId) === '20')!
@@ -131,7 +174,7 @@ test('pendingCivicTransfers reports the bay, both counterparties, and the tail',
 
 test('a grouped tail transfer is not callable', () => {
     const lanes = [makeLane(1, [shuttleTask(20, 21, 7)])]
-    const [transfer] = pendingCivicTransfers({lanes} as never)
+    const [transfer] = pendingCivicTransfers({lanes} as never, T0)
     expect(transfer.isTail).toBe(true)
     expect(transfer.callable).toBe(false)
 })
@@ -142,9 +185,9 @@ test('civicTransfersFrom counts only the ships a player sends from', () => {
         makeLane(2, [shuttleTask(22, 23)]),
     ]
     const entity = {lanes} as never
-    expect(civicTransfersFrom(entity, [20, 22]).length).toBe(2)
-    expect(civicTransfersFrom(entity, [30]).length).toBe(1)
-    expect(civicTransfersFrom(entity, [99]).length).toBe(0)
+    expect(civicTransfersFrom(entity, [20, 22], T0).length).toBe(2)
+    expect(civicTransfersFrom(entity, [30], T0).length).toBe(1)
+    expect(civicTransfersFrom(entity, [99], T0).length).toBe(0)
 })
 
 test('civicTransfersAtCap trips at the per-player cap', () => {
@@ -154,6 +197,6 @@ test('civicTransfersAtCap trips at the per-player cap', () => {
     const senderIds = mine.map((_, i) => 20 + i)
     const under = {lanes: [makeLane(1, mine.slice(0, -1))]} as never
     const at = {lanes: [makeLane(1, mine)]} as never
-    expect(civicTransfersAtCap(under, senderIds)).toBe(false)
-    expect(civicTransfersAtCap(at, senderIds)).toBe(true)
+    expect(civicTransfersAtCap(under, senderIds, T0)).toBe(false)
+    expect(civicTransfersAtCap(at, senderIds, T0)).toBe(true)
 })

package/src/influence/civic-shuttle.ts

@@ -22,10 +22,25 @@ export interface CivicShuttleBay {
     full: boolean
 }
 
+// a landed booking clears during the next civicshuttle, so only unfinished tasks occupy a bay
+function unfinishedTasks(lane: Lane | undefined, now: Date): number {
+    if (!lane) return 0
+    const startedMs = lane.schedule.started.toDate().getTime()
+    const nowMs = now.getTime()
+    let endSec = 0
+    let count = 0
+    for (const task of lane.schedule.tasks) {
+        endSec += task.duration.toNumber()
+        if (startedMs + endSec * 1000 > nowMs) count++
+    }
+    return count
+}
+
 export function civicShuttleBays(
     modules: ModuleEntry[],
     entityItemId: number,
-    lanes: Lane[]
+    lanes: Lane[],
+    now: Date = new Date()
 ): CivicShuttleBay[] {
     const bays: CivicShuttleBay[] = []
     for (let slotIndex = 0; slotIndex < modules.length; slotIndex++) {
@@ -35,7 +50,7 @@ export function civicShuttleBays(
         const laneKey = laneKeyForModule(slotIndex)
         const loader = resolveLaneLoader(modules, entityItemId, laneKey)
         const lane = lanes.find((l) => l.lane_key.toNumber() === laneKey)
-        const queued = lane ? lane.schedule.tasks.length : 0
+        const queued = unfinishedTasks(lane, now)
         bays.push({
             laneKey,
             slotIndex,
@@ -53,9 +68,10 @@ export function civicShuttleBays(
 export function selectCivicShuttleBay(
     modules: ModuleEntry[],
     entityItemId: number,
-    lanes: Lane[]
+    lanes: Lane[],
+    now: Date = new Date()
 ): CivicShuttleBay | undefined {
-    const bays = civicShuttleBays(modules, entityItemId, lanes)
+    const bays = civicShuttleBays(modules, entityItemId, lanes, now)
     return bays.find((bay) => bay.queued === 0) ?? bays[0]
 }
 
@@ -68,10 +84,14 @@ export interface PendingCivicTransfer {
     startsAt: Date
     completesAt: Date
     isTail: boolean
+    complete: boolean
     callable: boolean
 }
 
-export function pendingCivicTransfers(entity: ScheduleData): PendingCivicTransfer[] {
+export function pendingCivicTransfers(
+    entity: ScheduleData,
+    now: Date = new Date()
+): PendingCivicTransfer[] {
     const tailIndex = new Map<number, number>()
     for (const l of entity.lanes ?? []) {
         tailIndex.set(l.lane_key.toNumber(), l.schedule.tasks.length - 1)
@@ -83,6 +103,7 @@ export function pendingCivicTransfers(entity: ScheduleData): PendingCivicTransfe
         const push = entry.task.couplings.find((c) => c.kind.toNumber() === HoldKind.PUSH)
         if (!pull || !push) continue
         const isTail = tailIndex.get(entry.laneKey) === entry.taskIndex
+        const complete = entry.completesAt.getTime() <= now.getTime()
         out.push({
             laneKey: entry.laneKey,
             taskIndex: entry.taskIndex,
@@ -92,7 +113,8 @@ export function pendingCivicTransfers(entity: ScheduleData): PendingCivicTransfe
             startsAt: entry.startsAt,
             completesAt: entry.completesAt,
             isTail,
-            callable: isTail && !entry.task.entitygroup,
+            complete,
+            callable: isTail && !complete && !entry.task.entitygroup,
         })
     }
     return out
@@ -101,15 +123,20 @@ export function pendingCivicTransfers(entity: ScheduleData): PendingCivicTransfe
 // Mirrors civic_transfers_for: the sender side of every shuttle the building holds, by owner.
 export function civicTransfersFrom(
     entity: ScheduleData,
-    senderIds: Array<UInt64 | string | number>
+    senderIds: Array<UInt64 | string | number>,
+    now: Date = new Date()
 ): PendingCivicTransfer[] {
     const owned = new Set(senderIds.map((id) => String(id)))
-    return pendingCivicTransfers(entity).filter((t) => owned.has(String(t.senderId)))
+    return pendingCivicTransfers(entity, now).filter((t) => owned.has(String(t.senderId)))
 }
 
 export function civicTransfersAtCap(
     entity: ScheduleData,
-    senderIds: Array<UInt64 | string | number>
+    senderIds: Array<UInt64 | string | number>,
+    now: Date = new Date()
 ): boolean {
-    return civicTransfersFrom(entity, senderIds).length >= CIVIC_TRANSFER_PER_PLAYER_CAP
+    return (
+        civicTransfersFrom(entity, senderIds, now).filter((t) => !t.complete).length >=
+        CIVIC_TRANSFER_PER_PLAYER_CAP
+    )
 }