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

package/package.json

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

package/src/index-module.ts

@@ -204,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.ts

@@ -102,11 +102,10 @@ export class ConstructionManager extends BaseManager {
                 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((startedMs + cumulativeSec * 1000 - nowMs) / 1000)
-                )
+                const etaSeconds = Math.max(0, Math.round((projectedEndMs - nowMs) / 1000))
                 let perTarget = buckets.get(targetIdStr)
                 if (!perTarget) {
                     perTarget = new Map()

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: