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

package/src/derivation/capabilities.ts

@@ -55,7 +55,7 @@ export const GATHERER_DEPTH_TABLE: readonly GathererDepthParams[] = [
     {floor: 46000, slope: 12},
     {floor: 53500, slope: 10},
     {floor: 60000, slope: 5},
-    {floor: 63500, slope: 2},
+    {floor: 63537, slope: 2},
 ]
 
 export const GATHERER_DEPTH_MAX_TIER = 10
@@ -175,6 +175,7 @@ import {decodeCraftedItemStats} from './crafting'
 import {
     applySlotMultiplier,
     clampUint16,
+    clampUint32,
     getSlotAmp,
     type InstalledModule,
 } from '../entities/slot-multiplier'
@@ -346,8 +347,8 @@ export function computeEntityCapabilities(
     }
     if (hasGenerator) {
         result.generator = {
-            capacity: clampUint16(totalGenCapacity),
-            recharge: clampUint16(totalGenRecharge),
+            capacity: clampUint32(totalGenCapacity),
+            recharge: clampUint32(totalGenRecharge),
         }
     }
     if (hasGatherer) {

package/src/entities/slot-multiplier.ts

@@ -28,6 +28,8 @@ export function clampUint16(value: number): number {
     return Math.min(value, U16_MAX)
 }
 
+export const clampUint32 = (v: number): number => Math.min(Math.max(Math.floor(v), 0), 4294967295)
+
 export function applySlotMultiplier(value: number, outputPct: number): number {
     return clampUint16(Math.floor((value * outputPct) / 100))
 }

package/src/managers/actions.ts

@@ -252,6 +252,12 @@ export class ActionsManager extends BaseManager {
         })
     }
 
+    claimStarter(owner: NameType): Action {
+        return this.server.action('claimstarter', {
+            owner: Name.from(owner),
+        })
+    }
+
     async wrapEntity(
         owner: NameType,
         entityId: UInt64Type,

package/src/managers/construction-types.ts

@@ -67,7 +67,8 @@ export interface ScheduledBuild {
     hasStarted: boolean
     startsAt: number
     completesAt: number
-    trailingCancelCount: number
+    cancelable: boolean
+    blockingTaskCount: number
 }
 
 export interface Reservation {

package/src/managers/construction.ts

@@ -142,51 +142,105 @@ export class ConstructionManager extends BaseManager {
         return out
     }
 
+    private plotReservation(
+        plot: ServerContract.Types.entity_info,
+        now: Date
+    ): {
+        builderId: UInt64
+        group?: UInt64
+        startsAt: number
+        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(),
+                }
+            }
+            startSec += task.duration.toNumber()
+        }
+        return null
+    }
+
+    private builderCancelability(
+        builder: ServerContract.Types.entity_info | undefined,
+        group: UInt64 | undefined
+    ): {cancelable: boolean; blockingTaskCount: number} {
+        if (!builder?.schedule || 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}
+    }
+
+    private buildFromReservation(
+        res: {
+            builderId: UInt64
+            group?: UInt64
+            startsAt: number
+            completesAt: number
+            hasStarted: boolean
+        },
+        builder: ServerContract.Types.entity_info | undefined
+    ): ScheduledBuild {
+        const {cancelable, blockingTaskCount} = this.builderCancelability(builder, res.group)
+        return {
+            shipId: res.builderId,
+            shipName: builder?.entity_name || res.builderId.toString(),
+            hasStarted: res.hasStarted,
+            startsAt: res.startsAt,
+            completesAt: res.completesAt,
+            cancelable,
+            blockingTaskCount,
+        }
+    }
+
     scheduledBuildFor(
-        plotId: UInt64,
+        plot: ServerContract.Types.entity_info,
         entities: ServerContract.Types.entity_info[],
         now: Date
     ): ScheduledBuild | null {
-        return this.scheduledBuildsByTarget(entities, now).get(plotId.toString()) ?? null
+        const res = this.plotReservation(plot, now)
+        if (!res) return null
+        const builder = entities.find((e) => e.id.equals(res.builderId))
+        return this.buildFromReservation(res, builder)
     }
 
     scheduledBuildsByTarget(
         entities: ServerContract.Types.entity_info[],
         now: Date
     ): Map<string, ScheduledBuild> {
-        const nowMs = now.getTime()
-        const best = new Map<string, ScheduledBuild>()
+        const byId = new Map(entities.map((e) => [e.id.toString(), e]))
+        const out = new Map<string, ScheduledBuild>()
         for (const entity of entities) {
-            const schedule = entity.schedule
-            if (!schedule) continue
-            const startedMs = schedule.started.toDate().getTime()
-            const tasks = schedule.tasks
-            let cumulativeSec = 0
-            for (let i = 0; i < tasks.length; i++) {
-                const task = tasks[i]
-                const startSec = cumulativeSec
-                cumulativeSec += task.duration.toNumber()
-                if (task.type.toNumber() !== TaskType.BUILDPLOT) continue
-                if (!task.entitytarget) continue
-                const completesAt = startedMs + cumulativeSec * 1000
-                if (completesAt < nowMs) continue
-                const startsAt = startedMs + startSec * 1000
-                const targetId = task.entitytarget.entity_id.toString()
-                const candidate: ScheduledBuild = {
-                    shipId: entity.id,
-                    shipName: entity.entity_name || entity.id.toString(),
-                    hasStarted: startsAt <= nowMs,
-                    startsAt,
-                    completesAt,
-                    trailingCancelCount: tasks.length - 1 - i,
-                }
-                const existing = best.get(targetId)
-                if (!existing || candidate.completesAt < existing.completesAt) {
-                    best.set(targetId, candidate)
-                }
-            }
+            if (entity.type.toString() !== 'plot') continue
+            const res = this.plotReservation(entity, now)
+            if (!res) continue
+            const builder = byId.get(res.builderId.toString())
+            out.set(entity.id.toString(), this.buildFromReservation(res, builder))
         }
-        return best
+        return out
     }
 
     reservationsFrom(

package/src/scheduling/schedule.ts

@@ -60,7 +60,10 @@ export function scheduleRemaining(entity: ScheduleData, now: Date): number {
 }
 
 export function scheduleComplete(entity: ScheduleData, now: Date): boolean {
-    return hasSchedule(entity) && scheduleRemaining(entity, now) === 0
+    if (!hasSchedule(entity)) return false
+    if ((entity.schedule?.tasks ?? []).some((t) => t.type.toNumber() === TaskType.RESERVED))
+        return false
+    return scheduleRemaining(entity, now) === 0
 }
 
 export function currentTaskIndex(entity: ScheduleData, now: Date): number {
@@ -124,6 +127,8 @@ export function getTaskRemaining(entity: ScheduleData, index: number, now: Date)
 export function isTaskComplete(entity: ScheduleData, index: number, now: Date): boolean {
     if (!entity.schedule || index < 0 || index >= entity.schedule.tasks.length) return false
 
+    if (entity.schedule.tasks[index].type.toNumber() === TaskType.RESERVED) return false
+
     const taskDuration = entity.schedule.tasks[index].duration.toNumber()
     const taskElapsed = getTaskElapsed(entity, index, now)
     return taskElapsed >= taskDuration

package/src/capabilities/loading.ts

@@ -1,8 +0,0 @@
-import {UInt32, type UInt64} from '@wharfkit/antelope'
-import type {LoaderCapability} from '../types/capabilities'
-
-export function calcLoadDuration(entity: LoaderCapability, cargoMass: UInt64): UInt32 {
-    const totalThrust = entity.loaders.thrust.toNumber() * entity.loaders.quantity.toNumber()
-    if (totalThrust === 0) return UInt32.from(0)
-    return UInt32.from(Math.ceil(Number(cargoMass) / totalThrust))
-}