@shipload/sdk 1.0.0-next.3 → 1.0.0-next.30

package/src/nft/description.ts

@@ -4,6 +4,7 @@ import {
     MODULE_ENGINE,
     MODULE_GATHERER,
     MODULE_GENERATOR,
+    MODULE_HAULER,
     MODULE_LOADER,
     MODULE_STORAGE,
     MODULE_WARP,
@@ -13,8 +14,10 @@ import {
     ITEM_CONTAINER_T2_PACKED,
     ITEM_CRAFTER_T1,
     ITEM_ENGINE_T1,
+    ITEM_EXTRACTOR_T1_PACKED,
     ITEM_GATHERER_T1,
     ITEM_GENERATOR_T1,
+    ITEM_HAULER_T1,
     ITEM_LOADER_T1,
     ITEM_SHIP_T1_PACKED,
     ITEM_STORAGE_T1,
@@ -22,6 +25,8 @@ import {
     ITEM_WARP_T1,
 } from '../data/item-ids'
 import {decodeStat} from '../derivation/crafting'
+import {gathererDepthForTier} from '../derivation/capabilities'
+import {getItem} from '../data/catalog'
 
 function idiv(a: number, b: number): number {
     return Math.floor(a / b)
@@ -29,32 +34,35 @@ function idiv(a: number, b: number): number {
 
 export function computeBaseHullmass(stats: bigint): number {
     const density = decodeStat(stats, 1)
-    return 25000 + 75 * density
+    return 100000 - 75 * density
 }
 
 export function computeBaseCapacityShip(stats: bigint): number {
     const s = decodeStat(stats, 0) + decodeStat(stats, 2) + decodeStat(stats, 3)
-    return Math.floor(1_000_000 * 10 ** (s / 2997))
+    return Math.floor(5_000_000 * 6 ** (s / 2997))
 }
 
 export function computeBaseCapacityWarehouse(stats: bigint): number {
     const s = decodeStat(stats, 0) + decodeStat(stats, 2) + decodeStat(stats, 3)
-    return Math.floor(20_000_000 * 10 ** (s / 2997))
+    return Math.floor(100_000_000 * 6 ** (s / 2997))
 }
 
 export const computeEngineThrust = (vol: number): number => 400 + idiv(vol * 3, 4)
-export const computeEngineDrain = (thm: number): number => Math.max(30, 50 - idiv(thm, 70))
-export const computeGeneratorCap = (res: number): number => 300 + idiv(res, 6)
-export const computeGeneratorRech = (ref: number): number => 1 + idiv(ref * 3, 1000)
+export const computeEngineDrain = (thm: number): number => 2 * Math.max(30, 50 - idiv(thm, 70))
+export const computeGeneratorCap = (com: number): number => 950 + idiv(com, 2)
+export const computeGeneratorRech = (fin: number): number => 2 * (1 + idiv(fin * 3, 1000))
 export const computeGathererYield = (str: number): number => 200 + str
 export const computeGathererDrain = (con: number): number =>
-    Math.max(250, 1250 - idiv(con * 25, 20))
-export const computeGathererDepth = (tol: number): number => 200 + idiv(tol * 3, 2)
-export const computeGathererSpeed = (ref: number): number => 100 + idiv(ref * 4, 5)
-export const computeLoaderMass = (fin: number): number => Math.max(200, 2000 - fin * 2)
+    2 * Math.max(250, 1250 - idiv(con * 25, 20))
+export const computeGathererDepth = (tol: number, tier: number): number =>
+    gathererDepthForTier(tol, tier)
+export const computeLoaderMass = (ins: number): number => Math.max(200, 2000 - ins * 2)
 export const computeLoaderThrust = (pla: number): number => 1 + idiv(pla, 500)
 export const computeCrafterSpeed = (rea: number): number => 100 + idiv(rea * 4, 5)
-export const computeCrafterDrain = (com: number): number => Math.max(5, 30 - idiv(com, 33))
+export const computeCrafterDrain = (fin: number): number => Math.max(5, 30 - idiv(fin, 33))
+export const computeHaulerCapacity = (fin: number): number => Math.max(1, 1 + idiv(fin, 400))
+export const computeHaulerEfficiency = (con: number): number => 2000 + con * 6
+export const computeHaulerDrain = (com: number): number => Math.max(3, 15 - idiv(com, 80))
 export const computeWarpRange = (stat: number): number => 100 + stat * 3
 
 export function entityDisplayName(itemId: number): string {
@@ -63,6 +71,8 @@ export function entityDisplayName(itemId: number): string {
             return 'Ship'
         case ITEM_WAREHOUSE_T1_PACKED:
             return 'Warehouse'
+        case ITEM_EXTRACTOR_T1_PACKED:
+            return 'Extractor'
         case ITEM_CONTAINER_T1_PACKED:
             return 'Container'
         case ITEM_CONTAINER_T2_PACKED:
@@ -86,6 +96,8 @@ export function moduleDisplayName(itemId: number): string {
             return 'Crafter'
         case ITEM_STORAGE_T1:
             return 'Storage'
+        case ITEM_HAULER_T1:
+            return 'Hauler'
         case ITEM_WARP_T1:
             return 'Warp'
         default:
@@ -119,11 +131,12 @@ export function formatModuleLine(slot: number, itemId: number, stats: bigint): s
         case MODULE_GATHERER: {
             const str = decodeStat(stats, 0)
             const tol = decodeStat(stats, 1)
-            const con = decodeStat(stats, 3)
-            const ref = decodeStat(stats, 4)
+            const con = decodeStat(stats, 2)
+            const tier = getItem(itemId).tier
             out += `  Yield ${computeGathererYield(str)}  Depth ${computeGathererDepth(
-                tol
-            )}  Speed ${computeGathererSpeed(ref)}  Drain ${computeGathererDrain(con)}`
+                tol,
+                tier
+            )}  Drain ${computeGathererDrain(con)}`
             break
         }
         case MODULE_LOADER: {
@@ -147,6 +160,13 @@ export function formatModuleLine(slot: number, itemId: number, stats: bigint): s
             out += `  +${pct}% capacity`
             break
         }
+        case MODULE_HAULER: {
+            const res = decodeStat(stats, 0)
+            const pla = decodeStat(stats, 1)
+            const ref = decodeStat(stats, 2)
+            out += `  Capacity ${computeHaulerCapacity(res)}  Efficiency ${computeHaulerEfficiency(pla)}  Drain ${computeHaulerDrain(ref)}`
+            break
+        }
         case MODULE_WARP: {
             const stat = decodeStat(stats, 0)
             out += `  Range ${computeWarpRange(stat)}`
@@ -168,6 +188,8 @@ export function buildEntityDescription(
         baseCapacity = computeBaseCapacityShip(hullStats)
     } else if (itemId === ITEM_WAREHOUSE_T1_PACKED) {
         baseCapacity = computeBaseCapacityWarehouse(hullStats)
+    } else if (itemId === ITEM_EXTRACTOR_T1_PACKED) {
+        baseCapacity = computeBaseCapacityShip(hullStats)
     }
 
     let out = entityDisplayName(itemId)

package/src/nft/index.ts

@@ -1,2 +1,5 @@
 export * from './deserializers'
 export * from './description'
+export * from './atomicdata'
+export * from './atomicassets'
+export * from './buildImmutableData'

package/src/resolution/describe-module.ts

@@ -53,25 +53,22 @@ const TEMPLATES: Record<string, TemplateSpec> = {
     gatherer: {
         id: 'module.gatherer.description',
         template:
-            'mines resources at {yield} speed to a max depth of {depth} with {speed} gather speed while draining {drain} energy per second',
+            'mines resources at {yield} yield to a max depth of {depth} while draining {drain} energy per second',
         params: [
             ['yield', 'Yield'],
-            ['drain', 'Drain'],
             ['depth', 'Depth'],
-            ['speed', 'Speed'],
+            ['drain', 'Drain'],
         ],
-        highlightKeys: ['yield', 'depth', 'speed', 'drain'],
+        highlightKeys: ['yield', 'depth', 'drain'],
     },
     loader: {
         id: 'module.loader.description',
-        template:
-            '{quantity} loader that generates {thrust} thrust with a weight of {mass} per unit',
+        template: 'generates {thrust} thrust with a weight of {mass} per unit',
         params: [
-            ['quantity', 'Quantity'],
             ['thrust', 'Thrust'],
             ['mass', 'Mass'],
         ],
-        highlightKeys: ['quantity', 'thrust', 'mass'],
+        highlightKeys: ['thrust', 'mass'],
     },
     crafter: {
         id: 'module.crafter.description',

package/src/resolution/display-name.ts

@@ -1,22 +1,50 @@
 import type {ResolvedItem} from './resolve-item'
 import type {ResourceCategory} from '../types'
-import {CATEGORY_LABELS, TIER_ADJECTIVES} from '../types'
+import {
+    CATEGORY_LABELS,
+    RESOURCE_TIER_ADJECTIVES,
+    COMPONENT_TIER_PREFIXES,
+    MODULE_TIER_PREFIXES,
+} from '../types'
 import {formatMass as defaultFormatMass} from '../format'
 
-export interface DisplayNameInput {
-    itemType: 'resource' | 'component' | 'module' | 'entity' | string
+interface DisplayNameInputCommon {
     tier: number
     category?: ResourceCategory
     name: string
 }
 
-export function displayName(resolved: DisplayNameInput): string {
-    if (resolved.itemType === 'resource') {
-        const adj = TIER_ADJECTIVES[resolved.tier] ?? 'Unknown'
-        const cat = resolved.category ? CATEGORY_LABELS[resolved.category] : 'Resource'
-        return `${adj} ${cat}`
-    }
-    return resolved.name
+export type DisplayNameInput =
+    | (DisplayNameInputCommon & {itemType: 'resource' | 'component' | 'module' | 'entity' | string})
+    | (DisplayNameInputCommon & {type: string})
+
+function itemTypeOf(item: DisplayNameInput): string {
+    return 'itemType' in item ? item.itemType : item.type
+}
+
+function tierPrefix(item: DisplayNameInput): string | null {
+    const t = itemTypeOf(item)
+    if (t === 'resource') return RESOURCE_TIER_ADJECTIVES[item.tier] ?? null
+    if (t === 'component') return COMPONENT_TIER_PREFIXES[item.tier] ?? null
+    if (t === 'module') return MODULE_TIER_PREFIXES[item.tier] ?? null
+    return null
+}
+
+function rootName(item: DisplayNameInput): string {
+    if (itemTypeOf(item) !== 'resource') return item.name
+    return item.category ? CATEGORY_LABELS[item.category] : 'Resource'
+}
+
+// Tier-free display name: includes the resource tier adjective / component-module
+// prefix, but no "(T#)" suffix. Use this when the tier is shown separately.
+export function baseName(item: DisplayNameInput): string {
+    const prefix = tierPrefix(item)
+    const root = rootName(item)
+    return prefix ? `${prefix} ${root}` : root
+}
+
+export function displayName(item: DisplayNameInput): string {
+    return `${baseName(item)} (T${item.tier})`
 }
 
 export interface DescribeOptions {

package/src/resolution/resolve-item.ts

@@ -26,19 +26,15 @@ import {
     computeLoaderCapabilities,
     computeShipHullCapabilities,
     computeWarehouseHullCapabilities,
-} from '../entities/ship-deploy'
-import {computeContainerCapabilities, computeContainerT2Capabilities} from '../entities/container'
-import {
-    categoryColors,
-    categoryIcons,
-    componentIcon,
-    itemAbbreviations,
-    moduleIcon,
-} from '../data/colors'
+    computeContainerCapabilities,
+    computeContainerT2Capabilities,
+} from '../derivation/capabilities'
+import {categoryColors, componentIcon, itemAbbreviations, moduleIcon} from '../data/colors'
 import type {ServerContract} from '../contracts'
 import {
     ITEM_CONTAINER_T1_PACKED,
     ITEM_CONTAINER_T2_PACKED,
+    ITEM_EXTRACTOR_T1_PACKED,
     ITEM_SHIP_T1_PACKED,
     ITEM_WAREHOUSE_T1_PACKED,
 } from '../data/item-ids'
@@ -109,7 +105,7 @@ function resolveResource(id: number, stats?: UInt64Type): ResolvedItem {
     return {
         itemId: id,
         name: item.name,
-        icon: cat ? categoryIcons[cat] : '⬡',
+        icon: '',
         abbreviation: null,
         category: cat,
         tier: item.tier,
@@ -155,7 +151,8 @@ function resolveComponent(id: number, stats?: UInt64Type): ResolvedItem {
 
 function computeCapabilityGroup(
     moduleType: number,
-    stats: Record<string, number>
+    stats: Record<string, number>,
+    tier: number
 ): ResolvedAttributeGroup | undefined {
     switch (moduleType) {
         case MODULE_ENGINE: {
@@ -179,14 +176,13 @@ function computeCapabilityGroup(
             }
         }
         case MODULE_GATHERER: {
-            const caps = computeGathererCapabilities(stats)
+            const caps = computeGathererCapabilities(stats, tier)
             return {
                 capability: 'Gatherer',
                 attributes: [
                     {label: 'Yield', value: caps.yield},
                     {label: 'Drain', value: caps.drain},
                     {label: 'Depth', value: caps.depth},
-                    {label: 'Speed', value: caps.speed},
                 ],
             }
         }
@@ -223,10 +219,11 @@ function computeCapabilityGroup(
             }
         }
         case MODULE_STORAGE: {
-            const str = stats.strength ?? 500
-            const hrd = stats.hardness ?? 500
-            const sat = stats.saturation ?? 500
-            const statSum = str + hrd + sat
+            const str = stats.strength
+            const den = stats.density
+            const hrd = stats.hardness
+            const com = stats.cohesion
+            const statSum = str + den + hrd + com
             const pct = 10 + Math.floor((statSum * 10) / 2997)
             return {capability: 'Storage', attributes: [{label: 'Capacity Bonus', value: pct}]}
         }
@@ -241,7 +238,7 @@ function resolveModule(id: number, stats?: UInt64Type): ResolvedItem {
     if (stats !== undefined) {
         const decoded = decodeCraftedItemStats(id, toBigStats(stats))
         const modType = getModuleCapabilityType(id)
-        const group = computeCapabilityGroup(modType, decoded)
+        const group = computeCapabilityGroup(modType, decoded, item.tier)
         if (group) attributes = [group]
     }
     return {
@@ -268,6 +265,8 @@ function hullCapsForEntity(
             return computeShipHullCapabilities(decoded)
         case ITEM_WAREHOUSE_T1_PACKED:
             return computeWarehouseHullCapabilities(decoded)
+        case ITEM_EXTRACTOR_T1_PACKED:
+            return computeShipHullCapabilities(decoded)
         case ITEM_CONTAINER_T1_PACKED:
             return computeContainerCapabilities(decoded)
         case ITEM_CONTAINER_T2_PACKED:
@@ -310,13 +309,16 @@ function resolveEntity(
                 const modStats = BigInt(mod.installed.stats.toString())
                 const decodedStats = decodeCraftedItemStats(modItemId, modStats)
                 const modType = getModuleCapabilityType(modItemId)
-                const group = computeCapabilityGroup(modType, decodedStats)
                 let modName = 'Module'
+                let modTier = 1
                 try {
-                    modName = getItem(modItemId).name
+                    const modItem = getItem(modItemId)
+                    modName = modItem.name
+                    modTier = modItem.tier
                 } catch {
                     modName = itemMetadata[modItemId]?.name ?? 'Module'
                 }
+                const group = computeCapabilityGroup(modType, decodedStats, modTier)
                 return {
                     name: modName,
                     installed: true,

package/src/scheduling/accessor.ts

@@ -1,82 +1,128 @@
 import type {ServerContract} from '../contracts'
 import type {TaskType} from '../types'
-import type {ScheduleData} from './schedule'
-import * as schedule from './schedule'
+import * as core from './lane-core'
+import {
+    activeTasks,
+    getLane,
+    getLanes,
+    hasSchedule,
+    isIdle,
+    LANE_MOBILITY,
+    type LaneView,
+    type ScheduleData,
+} from './schedule'
 
 type Task = ServerContract.Types.task
 
 export class ScheduleAccessor {
-    constructor(private entity: ScheduleData) {}
+    private _laneResolved = false
+    private _lane: LaneView | undefined
+
+    constructor(
+        private entity: ScheduleData,
+        private laneKey: number = LANE_MOBILITY
+    ) {}
+
+    private get lane(): LaneView | undefined {
+        if (!this._laneResolved) {
+            this._lane = getLane(this.entity, this.laneKey)
+            this._laneResolved = true
+        }
+        return this._lane
+    }
+
+    forLane(laneKey: number): ScheduleAccessor {
+        return new ScheduleAccessor(this.entity, laneKey)
+    }
+
+    get lanes(): LaneView[] {
+        return getLanes(this.entity)
+    }
 
     get hasSchedule(): boolean {
-        return schedule.hasSchedule(this.entity)
+        return hasSchedule(this.entity)
     }
 
     get isIdle(): boolean {
-        return schedule.isIdle(this.entity)
+        return isIdle(this.entity)
     }
 
     get tasks(): Task[] {
-        return schedule.getTasks(this.entity)
+        return this.lane?.schedule.tasks ?? []
+    }
+
+    activeTasks(now: Date): Task[] {
+        return activeTasks(this.entity, now)
     }
 
     duration(): number {
-        return schedule.scheduleDuration(this.entity)
+        return this.lane ? core.laneDuration(this.lane.schedule) : 0
     }
 
     elapsed(now: Date): number {
-        return schedule.scheduleElapsed(this.entity, now)
+        return this.lane ? core.laneElapsed(this.lane.schedule, now) : 0
     }
 
     remaining(now: Date): number {
-        return schedule.scheduleRemaining(this.entity, now)
+        return this.lane ? core.laneRemaining(this.lane.schedule, now) : 0
+    }
+
+    startsIn(now: Date): number {
+        return this.lane ? core.laneStartsIn(this.lane.schedule, now) : 0
     }
 
     complete(now: Date): boolean {
-        return schedule.scheduleComplete(this.entity, now)
+        return this.lane ? core.laneComplete(this.lane.schedule, now) : false
     }
 
     currentTaskIndex(now: Date): number {
-        return schedule.currentTaskIndex(this.entity, now)
+        return this.lane ? core.currentTaskIndexForLane(this.lane.schedule, now) : -1
     }
 
     currentTask(now: Date): Task | undefined {
-        return schedule.currentTask(this.entity, now)
+        return this.lane ? core.currentTask(this.lane.schedule, now) : undefined
     }
 
     currentTaskType(now: Date): TaskType | undefined {
-        return schedule.currentTaskType(this.entity, now)
+        return this.lane ? core.currentTaskType(this.lane.schedule, now) : undefined
     }
 
     taskStartTime(index: number): number {
-        return schedule.getTaskStartTime(this.entity, index)
+        return this.lane ? core.laneTaskStartTime(this.lane.schedule, index) : 0
     }
 
     taskElapsed(index: number, now: Date): number {
-        return schedule.getTaskElapsed(this.entity, index, now)
+        return this.lane ? core.laneTaskElapsed(this.lane.schedule, index, now) : 0
     }
 
     taskRemaining(index: number, now: Date): number {
-        return schedule.getTaskRemaining(this.entity, index, now)
+        return this.lane ? core.laneTaskRemaining(this.lane.schedule, index, now) : 0
     }
 
     taskComplete(index: number, now: Date): boolean {
-        return schedule.isTaskComplete(this.entity, index, now)
+        return this.lane ? core.laneTaskComplete(this.lane.schedule, index, now) : false
     }
 
     taskInProgress(index: number, now: Date): boolean {
-        return schedule.isTaskInProgress(this.entity, index, now)
+        return this.lane ? core.laneTaskInProgress(this.lane.schedule, index, now) : false
     }
 
     currentTaskProgress(now: Date): number {
-        return schedule.currentTaskProgress(this.entity, now)
+        return this.lane ? core.currentTaskProgress(this.lane.schedule, now) : 0
+    }
+
+    currentTaskProgressFloat(now: Date): number {
+        return this.lane ? core.currentTaskProgressFloatForLane(this.lane.schedule, now) : 0
     }
 
     progress(now: Date): number {
-        return schedule.scheduleProgress(this.entity, now)
+        return this.lane ? core.laneProgress(this.lane.schedule, now) : 0
     }
 }
 
-export function createScheduleAccessor(entity: ScheduleData): ScheduleAccessor {
-    return new ScheduleAccessor(entity)
+export function createScheduleAccessor(
+    entity: ScheduleData,
+    laneKey: number = LANE_MOBILITY
+): ScheduleAccessor {
+    return new ScheduleAccessor(entity, laneKey)
 }

package/src/scheduling/availability.ts

@@ -0,0 +1,108 @@
+import type {ServerContract} from '../contracts'
+import {TaskType} from '../types'
+import * as schedule from './schedule'
+
+type Task = ServerContract.Types.task
+type CargoItem = ServerContract.Types.cargo_item
+
+export interface CargoEffect {
+    added: CargoItem[]
+    removed: CargoItem[]
+}
+
+export interface AvailabilityInput extends schedule.ScheduleData {
+    cargo: CargoItem[]
+}
+
+export function taskCargoEffect(task: Task): CargoEffect {
+    switch (task.type.toNumber()) {
+        case TaskType.LOAD:
+        case TaskType.UNWRAP:
+        case TaskType.UNDEPLOY:
+            return {added: task.cargo, removed: []}
+        case TaskType.UNLOAD:
+            return {added: [], removed: task.cargo}
+        case TaskType.GATHER:
+            return task.entitytarget ? {added: [], removed: []} : {added: task.cargo, removed: []}
+        case TaskType.CRAFT:
+            if (task.cargo.length === 0) return {added: [], removed: []}
+            return {added: [task.cargo[task.cargo.length - 1]], removed: task.cargo.slice(0, -1)}
+        case TaskType.DEPLOY:
+            return task.cargo.length > 0
+                ? {added: [], removed: [task.cargo[0]]}
+                : {added: [], removed: []}
+        default:
+            return {added: [], removed: []}
+    }
+}
+
+function cargoKey(item: CargoItem): string {
+    const base = `${item.item_id.toNumber()}:${item.stats.toString()}`
+    const modules = item.modules ?? []
+    const entityId = item.entity_id?.toString()
+    const normalizedEntityId = entityId && entityId !== '0' ? entityId : ''
+    if (modules.length === 0 && normalizedEntityId === '') return base
+    return `${base}:modules=${JSON.stringify(modules)}:entity=${normalizedEntityId}`
+}
+
+function cargoQuantity(item: CargoItem): bigint {
+    return BigInt(item.quantity.toString())
+}
+
+export function projectedCargoAvailableAt(
+    entity: AvailabilityInput,
+    at: Date
+): Map<string, bigint> {
+    const avail = new Map<string, bigint>()
+
+    for (const item of entity.cargo) {
+        const key = cargoKey(item)
+        avail.set(key, (avail.get(key) ?? 0n) + cargoQuantity(item))
+    }
+
+    // Every scheduled task reserves inputs against the unsettled cargo base, even already-elapsed ones.
+    const tasks = schedule.orderedTasks(entity)
+
+    for (const ordered of tasks) {
+        if (ordered.completesAt.getTime() >= at.getTime()) continue
+
+        for (const item of taskCargoEffect(ordered.task).added) {
+            const key = cargoKey(item)
+            avail.set(key, (avail.get(key) ?? 0n) + cargoQuantity(item))
+        }
+    }
+
+    for (const ordered of tasks) {
+        for (const item of taskCargoEffect(ordered.task).removed) {
+            const key = cargoKey(item)
+            const current = avail.get(key) ?? 0n
+            const quantity = cargoQuantity(item)
+            avail.set(key, current > quantity ? current - quantity : 0n)
+        }
+    }
+
+    return avail
+}
+
+// Latest completion among scheduled tasks producing any of the given inputs (a craft starts no earlier).
+export function cargoReadyAt(entity: AvailabilityInput, inputItemIds: readonly number[]): Date {
+    let readyMs = 0
+    for (const ordered of schedule.orderedTasks(entity)) {
+        for (const item of taskCargoEffect(ordered.task).added) {
+            if (inputItemIds.includes(item.item_id.toNumber())) {
+                readyMs = Math.max(readyMs, ordered.completesAt.getTime())
+                break
+            }
+        }
+    }
+    return new Date(readyMs)
+}
+
+export function availableForItem(avail: Map<string, bigint>, itemId: number): bigint {
+    const prefix = `${itemId}:`
+    let total = 0n
+    for (const [key, quantity] of avail) {
+        if (key.startsWith(prefix)) total += quantity
+    }
+    return total
+}

package/src/scheduling/energy.ts

@@ -0,0 +1,48 @@
+import {TaskType} from '../types'
+import {createProjectedEntity, type Projectable} from './projection'
+import {orderedTasks} 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 ordered = orderedTasks(entity)
+    if (ordered.length === 0) return clamp(running)
+
+    const nowMs = now.getTime()
+
+    for (const {task, startsAt} of ordered) {
+        const duration = task.duration.toNumber()
+        const isReserved = task.type.toNumber() === TaskType.RESERVED
+        const elapsed = Math.min(
+            Math.max(0, Math.floor((nowMs - startsAt.getTime()) / 1000)),
+            duration
+        )
+        const complete = !isReserved && elapsed >= duration
+        const inProgress = !complete && elapsed > 0 && elapsed < duration
+
+        if (!complete && !inProgress) continue
+
+        const fraction = complete ? 1 : duration === 0 ? 1 : elapsed / duration
+
+        if (task.type.toNumber() === TaskType.RECHARGE) {
+            if (capacity !== undefined) {
+                running = complete ? capacity : running + (capacity - running) * fraction
+            }
+        } else {
+            const cost = Number(task.energy_cost ?? 0)
+            running -= cost * fraction
+        }
+
+        running = clamp(running)
+    }
+
+    return clamp(running)
+}