@shipload/sdk 1.0.0-next.7 → 1.0.0-next.70

package/src/scheduling/projection.ts

@@ -1,8 +1,7 @@
-import {Name, TimePoint, UInt16, UInt32, UInt64} from '@wharfkit/antelope'
+import {Name, type TimePoint, type UInt16, UInt32, UInt64} from '@wharfkit/antelope'
 import {ServerContract} from '../contracts'
-import {Coordinates, PRECISION, TaskType} from '../types'
+import {Coordinates, TaskType} from '../types'
 import {
-    capsHasLoaders,
     capsHasMovement,
     capsHasStorage,
     type EntityCapabilities,
@@ -14,38 +13,48 @@ import {
     RECIPE_INPUTS_INSUFFICIENT,
     RECIPE_INPUTS_INVALID,
     RECIPE_NOT_FOUND,
-    SHIP_CARGO_NOT_LOADED,
+    ENTITY_CARGO_NOT_LOADED,
 } from '../errors'
-import {getRecipe, type RecipeInput} from '../data/recipes-runtime'
-import {getItem} from '../data/catalog'
-import {distanceBetweenCoordinates, lerp} from '../travel/travel'
+import {getEntityLayout, getRecipe, type RecipeInput} from '../data/recipes-runtime'
+import {ITEM_SHIP_T1_PACKED} from '../data/item-ids'
+import {computeEntityCapabilities} from '../derivation/capabilities'
+import {decodeCraftedItemStats, decodeStat} from '../derivation/crafting'
+import {packedModulesToInstalled, type InstalledModule} from '../entities/slot-multiplier'
+import {lerp} from '../travel/travel'
 import {
     calcStacksMass,
     cargoItemToStack,
     type CargoStack,
     mergeStacks,
-    removeFromStacks,
+    subtractFromStacks,
     stackToCargoItem,
 } from '../capabilities/storage'
+import {hydrateEntityLanes} from '../entity/hydrate'
+import {craftCargoOwnership} from './availability'
 import * as schedule from './schedule'
 import type {ScheduleData} from './schedule'
 
 export interface ProjectedEntity {
     location: Coordinates
-    energy: UInt16
+    energy: UInt32
     cargo: CargoStack[]
     shipMass: UInt32
     capacity?: UInt64
     engines?: ServerContract.Types.movement_stats
-    loaders?: ServerContract.Types.loader_stats
+    loaderLanes: ServerContract.Types.loader_lane[]
     generator?: ServerContract.Types.energy_stats
     hauler?: ServerContract.Types.hauler_stats
+    launcher?: ServerContract.Types.launcher_stats
     readonly cargoMass: UInt64
     readonly totalMass: UInt64
+    readonly gathererLanes: ServerContract.Types.gatherer_lane[]
+    readonly crafterLanes: ServerContract.Types.crafter_lane[]
+    readonly builderLanes: ServerContract.Types.builder_lane[]
 
     hasMovement(): boolean
     hasStorage(): boolean
     hasLoaders(): boolean
+    hasLauncher(): boolean
 
     capabilities(): EntityCapabilities
     state(): EntityState
@@ -53,53 +62,196 @@ export interface ProjectedEntity {
 
 export interface Projectable extends ScheduleData {
     coordinates: Coordinates | ServerContract.Types.coordinates
-    energy?: UInt16
+    energy?: UInt32
     hullmass?: UInt32
     generator?: ServerContract.Types.energy_stats
     engines?: ServerContract.Types.movement_stats
-    loaders?: ServerContract.Types.loader_stats
+    loader_lanes?: ServerContract.Types.loader_lane[]
+    gatherer_lanes?: ServerContract.Types.gatherer_lane[]
+    crafter_lanes?: ServerContract.Types.crafter_lane[]
+    builder_lanes?: ServerContract.Types.builder_lane[]
     hauler?: ServerContract.Types.hauler_stats
+    launcher?: ServerContract.Types.launcher_stats
     capacity?: UInt32
     cargo: ServerContract.Types.cargo_item[]
     cargomass: UInt32
+    projected_at?: TimePoint
     owner?: Name
+    stats?: bigint
+    item_id?: number | UInt16
+    modules?: ServerContract.Types.module_entry[] | InstalledModule[]
 }
 
-function getHullMass(entity: Projectable): UInt32 {
-    return UInt32.from(entity.hullmass ?? 0)
+function toInstalledModules(
+    modules: ServerContract.Types.module_entry[] | InstalledModule[]
+): InstalledModule[] {
+    if (modules.length > 0 && 'itemId' in modules[0]) {
+        return modules as InstalledModule[]
+    }
+    return packedModulesToInstalled(modules as ServerContract.Types.module_entry[])
+}
+
+interface ProjectedCaps {
+    hullmass?: UInt32
+    capacity?: UInt32
+    engines?: ServerContract.Types.movement_stats
+    generator?: ServerContract.Types.energy_stats
+    loaderLanes: ServerContract.Types.loader_lane[]
+    gathererLanes: ServerContract.Types.gatherer_lane[]
+    crafterLanes: ServerContract.Types.crafter_lane[]
+    builderLanes: ServerContract.Types.builder_lane[]
+    hauler?: ServerContract.Types.hauler_stats
+    launcher?: ServerContract.Types.launcher_stats
+}
+
+function recomputeCaps(entity: Projectable): ProjectedCaps | undefined {
+    if (
+        entity.item_id === undefined ||
+        entity.modules === undefined ||
+        entity.stats === undefined
+    ) {
+        return undefined
+    }
+
+    const itemId = Number(
+        typeof entity.item_id === 'number' ? entity.item_id : entity.item_id.value
+    )
+    const hullStats = decodeCraftedItemStats(itemId, entity.stats)
+    if (hullStats.strength === undefined) hullStats.strength = decodeStat(entity.stats, 0)
+    if (hullStats.hardness === undefined) hullStats.hardness = decodeStat(entity.stats, 2)
+    // The retired Ship T1 recipe only assigned names to its first two stat slots.
+    // Its on-chain entity row still carries five packed channels, and the ship hull
+    // formula deliberately consumes all five. Keep the unlabelled channels internal
+    // to projection so replay remains contract-parity until deployment replaces it.
+    if (itemId === ITEM_SHIP_T1_PACKED) {
+        hullStats.__legacyShipChannel3 = decodeStat(entity.stats, 3)
+        hullStats.__legacyShipChannel4 = decodeStat(entity.stats, 4)
+    }
+    const layout = getEntityLayout(itemId)?.slots ?? []
+    const installed = toInstalledModules(entity.modules)
+    const caps = computeEntityCapabilities(hullStats, itemId, installed, layout)
+
+    const toLoaderLane = (l: {
+        slotIndex: number
+        mass: number
+        thrust: number
+        outputPct: number
+    }): ServerContract.Types.loader_lane =>
+        ServerContract.Types.loader_lane.from({
+            slot_index: l.slotIndex,
+            mass: l.mass,
+            thrust: l.thrust,
+            output_pct: l.outputPct,
+        })
+
+    const toCrafterLane = (l: {
+        slotIndex: number
+        speed: number
+        drain: number
+        outputPct: number
+    }): ServerContract.Types.crafter_lane =>
+        ServerContract.Types.crafter_lane.from({
+            slot_index: l.slotIndex,
+            speed: l.speed,
+            drain: l.drain,
+            output_pct: l.outputPct,
+        })
+
+    const toBuilderLane = (l: {
+        slotIndex: number
+        speed: number
+        drain: number
+        outputPct: number
+    }): ServerContract.Types.builder_lane =>
+        ServerContract.Types.builder_lane.from({
+            slot_index: l.slotIndex,
+            speed: l.speed,
+            drain: l.drain,
+            output_pct: l.outputPct,
+        })
+
+    return {
+        hullmass: UInt32.from(caps.hullmass),
+        capacity: UInt32.from(caps.capacity),
+        engines: caps.engines ? ServerContract.Types.movement_stats.from(caps.engines) : undefined,
+        generator: caps.generator
+            ? ServerContract.Types.energy_stats.from(caps.generator)
+            : undefined,
+        loaderLanes: (caps.loaderLanes ?? []).map(toLoaderLane),
+        gathererLanes: hydrateEntityLanes(caps),
+        crafterLanes: (caps.crafterLanes ?? []).map(toCrafterLane),
+        builderLanes: (caps.builderLanes ?? []).map(toBuilderLane),
+        hauler: caps.hauler
+            ? ServerContract.Types.hauler_stats.from({
+                  capacity: caps.hauler.capacity,
+                  efficiency: caps.hauler.efficiency,
+                  drain: caps.hauler.drain,
+                  capacity_by_tier: caps.hauler.capacityByTier,
+              })
+            : undefined,
+        launcher: caps.launcher
+            ? ServerContract.Types.launcher_stats.from({
+                  charge_rate: caps.launcher.chargeRate,
+                  velocity: caps.launcher.velocity,
+                  drain: caps.launcher.drain,
+              })
+            : undefined,
+    }
+}
+
+function loaderLanesTotalMass(lanes: ServerContract.Types.loader_lane[]): UInt64 {
+    let total = 0
+    for (const l of lanes) total += Number(l.mass)
+    return UInt64.from(total)
 }
 
 export function createProjectedEntity(entity: Projectable): ProjectedEntity {
-    const shipMass = getHullMass(entity)
-    const loaders = entity.loaders
-    const engines = entity.engines
-    const generator = entity.generator
-    const hauler = entity.hauler
-    const capacity = entity.capacity
+    const needsRecompute =
+        entity.hullmass === undefined ||
+        entity.loader_lanes === undefined ||
+        entity.engines === undefined ||
+        entity.generator === undefined ||
+        entity.hauler === undefined ||
+        entity.launcher === undefined ||
+        entity.capacity === undefined
+    const caps = needsRecompute ? recomputeCaps(entity) : undefined
+
+    const shipMass = UInt32.from(entity.hullmass ?? caps?.hullmass ?? 0)
+    const loaderLanes = entity.loader_lanes ?? caps?.loaderLanes ?? []
+    const gathererLanes = entity.gatherer_lanes ?? caps?.gathererLanes ?? []
+    const crafterLanes = entity.crafter_lanes ?? caps?.crafterLanes ?? []
+    const builderLanes = entity.builder_lanes ?? caps?.builderLanes ?? []
+    const engines = entity.engines ?? caps?.engines
+    const generator = entity.generator ?? caps?.generator
+    const hauler = entity.hauler ?? caps?.hauler
+    const launcher = entity.launcher ?? caps?.launcher
+    const capacity = entity.capacity ?? caps?.capacity
 
     const cargo: CargoStack[] = entity.cargo.map(cargoItemToStack)
 
     const projected: ProjectedEntity = {
         location: Coordinates.from(entity.coordinates),
-        energy: UInt16.from(entity.energy ?? 0),
+        energy: UInt32.from(entity.energy ?? 0),
         cargo,
         shipMass,
         capacity: capacity ? UInt64.from(capacity) : undefined,
         engines,
         generator,
         hauler,
-        loaders,
+        launcher,
+        loaderLanes,
+        gathererLanes,
+        crafterLanes,
+        builderLanes,
 
         get cargoMass() {
             return calcStacksMass(this.cargo)
         },
 
         get totalMass() {
-            let mass = UInt64.from(this.shipMass).adding(this.cargoMass)
-            if (this.loaders) {
-                mass = mass.adding(this.loaders.mass.multiplying(this.loaders.quantity))
-            }
-            return mass
+            return UInt64.from(this.shipMass)
+                .adding(this.cargoMass)
+                .adding(loaderLanesTotalMass(this.loaderLanes))
         },
 
         hasMovement() {
@@ -111,7 +263,11 @@ export function createProjectedEntity(entity: Projectable): ProjectedEntity {
         },
 
         hasLoaders() {
-            return capsHasLoaders(this.capabilities())
+            return this.loaderLanes.length > 0
+        },
+
+        hasLauncher() {
+            return this.launcher !== undefined
         },
 
         capabilities(): EntityCapabilities {
@@ -120,7 +276,7 @@ export function createProjectedEntity(entity: Projectable): ProjectedEntity {
                 capacity: this.capacity ? UInt32.from(this.capacity) : undefined,
                 engines: this.engines,
                 generator: this.generator,
-                loaders: this.loaders,
+                launcher: this.launcher,
             }
         },
 
@@ -146,12 +302,12 @@ function applyRechargeTask(
     if (!projected.generator) return
 
     if (options.complete) {
-        projected.energy = UInt16.from(projected.generator.capacity)
+        projected.energy = UInt32.from(projected.generator.capacity)
     } else if (options.progress !== undefined) {
         const capacity = Number(projected.generator.capacity)
         const currentEnergy = Number(projected.energy)
         const rechargeAmount = (capacity - currentEnergy) * options.progress
-        projected.energy = UInt16.from(Math.min(capacity, currentEnergy + rechargeAmount))
+        projected.energy = UInt32.from(Math.min(capacity, currentEnergy + rechargeAmount))
     }
 }
 
@@ -160,28 +316,25 @@ 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)
+            ? UInt32.from(projected.energy.subtracting(partialEnergy))
+            : UInt32.from(0)
     }
 }
 
@@ -190,7 +343,7 @@ function addCargoItem(projected: ProjectedEntity, item: ServerContract.Types.car
 }
 
 function removeCargoItem(projected: ProjectedEntity, item: ServerContract.Types.cargo_item): void {
-    projected.cargo = removeFromStacks(projected.cargo, cargoItemToStack(item))
+    projected.cargo = subtractFromStacks(projected.cargo, cargoItemToStack(item))
 }
 
 function applyAddCargoTask(projected: ProjectedEntity, task: ServerContract.Types.task): void {
@@ -207,10 +360,10 @@ function applyRemoveCargoTask(projected: ProjectedEntity, task: ServerContract.T
 
 function applyEnergyCost(projected: ProjectedEntity, task: ServerContract.Types.task): void {
     if (!task.energy_cost) return
-    const energyCost = UInt16.from(task.energy_cost)
+    const energyCost = UInt32.from(task.energy_cost)
     projected.energy = projected.energy.gt(energyCost)
-        ? UInt16.from(projected.energy.subtracting(energyCost))
-        : UInt16.from(0)
+        ? UInt32.from(projected.energy.subtracting(energyCost))
+        : UInt32.from(0)
 }
 
 function applyGatherTask(
@@ -220,7 +373,7 @@ function applyGatherTask(
 ): void {
     if (!options.complete) return
     applyEnergyCost(projected, task)
-    if (!task.entitytarget) {
+    if (task.couplings.length === 0) {
         applyAddCargoTask(projected, task)
     }
 }
@@ -229,16 +382,14 @@ function applyCraftTask(projected: ProjectedEntity, task: ServerContract.Types.t
     applyEnergyCost(projected, task)
     if (task.cargo.length === 0) return
 
-    for (let i = 0; i < task.cargo.length - 1; i++) {
-        removeCargoItem(projected, task.cargo[i])
+    const {clustered, ownOutput} = craftCargoOwnership(task)
+    if (!clustered) {
+        for (let i = 0; i < task.cargo.length - 1; i++) {
+            removeCargoItem(projected, task.cargo[i])
+        }
     }
-    addCargoItem(projected, task.cargo[task.cargo.length - 1])
-}
-
-function applyDeployTask(projected: ProjectedEntity, task: ServerContract.Types.task): void {
-    applyEnergyCost(projected, task)
-    if (task.cargo.length > 0) {
-        removeCargoItem(projected, task.cargo[0])
+    if (ownOutput) {
+        addCargoItem(projected, task.cargo[task.cargo.length - 1])
     }
 }
 
@@ -248,14 +399,25 @@ function applyTask(projected: ProjectedEntity, task: ServerContract.Types.task):
             applyRechargeTask(projected, task, {complete: true})
             break
         case TaskType.TRAVEL:
+        case TaskType.WARP:
+        case TaskType.TRANSIT:
             applyFlightTask(projected, task, {complete: true})
             break
         case TaskType.LOAD:
         case TaskType.UNWRAP:
+        case TaskType.CIVIC_WITHDRAW:
             applyAddCargoTask(projected, task)
             break
         case TaskType.UNLOAD:
-        case TaskType.WRAP:
+        case TaskType.CONTRIBUTE:
+            applyRemoveCargoTask(projected, task)
+            break
+        case TaskType.CIVIC_DEPOSIT:
+            applyEnergyCost(projected, task)
+            applyRemoveCargoTask(projected, task)
+            break
+        case TaskType.UPGRADE:
+            applyEnergyCost(projected, task)
             applyRemoveCargoTask(projected, task)
             break
         case TaskType.GATHER:
@@ -264,11 +426,9 @@ function applyTask(projected: ProjectedEntity, task: ServerContract.Types.task):
         case TaskType.CRAFT:
             applyCraftTask(projected, task)
             break
-        case TaskType.DEPLOY:
-            applyDeployTask(projected, task)
-            break
         case TaskType.UNDEPLOY:
-        case TaskType.WRAP_ENTITY:
+            applyAddCargoTask(projected, task)
+            break
         case TaskType.DEMOLISH:
             break
     }
@@ -278,52 +438,33 @@ export interface ProjectionOptions {
     upToTaskIndex?: number
 }
 
+function anchoredSkipCount(entity: Projectable, ordered: readonly schedule.OrderedTask[]): number {
+    return schedule.appliedTaskCount(entity, ordered)
+}
+
 export function projectEntity(entity: Projectable, options?: ProjectionOptions): ProjectedEntity {
     const projected = createProjectedEntity(entity)
-    if (!entity.schedule || entity.schedule.tasks.length === 0) return projected
+    const ordered = schedule.orderedTasks(entity)
+    if (ordered.length === 0) return projected
 
-    const tasks = entity.schedule.tasks
     const taskCount =
         options?.upToTaskIndex !== undefined
-            ? Math.max(0, Math.min(options.upToTaskIndex, tasks.length))
-            : tasks.length
+            ? Math.max(0, Math.min(options.upToTaskIndex, ordered.length))
+            : ordered.length
 
-    for (let i = 0; i < taskCount; i++) {
-        applyTask(projected, tasks[i])
+    for (let i = anchoredSkipCount(entity, ordered); i < taskCount; i++) {
+        applyTask(projected, ordered[i].task)
     }
     return projected
 }
 
-export interface ProjectableSnapshot extends Projectable {
-    current_task?: ServerContract.Types.task
-    pending_tasks?: ServerContract.Types.task[]
-}
-
-function buildRemainingProjectable(snapshot: ProjectableSnapshot): Projectable | null {
-    if (!snapshot.schedule) return null
-    const remainingTasks: ServerContract.Types.task[] = []
-    if (snapshot.current_task) remainingTasks.push(snapshot.current_task)
-    if (snapshot.pending_tasks?.length) remainingTasks.push(...snapshot.pending_tasks)
-    if (remainingTasks.length === 0) return null
-
-    const completedCount = snapshot.schedule.tasks.length - remainingTasks.length
-    let startedMs = snapshot.schedule.started.toMilliseconds()
-    for (let i = 0; i < completedCount; i++) {
-        startedMs += snapshot.schedule.tasks[i].duration.toNumber() * 1000
-    }
-
-    return {
-        ...snapshot,
-        schedule: ServerContract.Types.schedule.from({
-            started: TimePoint.fromMilliseconds(startedMs),
-            tasks: remainingTasks,
-        }),
+export function projectRemainingAt(entity: Projectable, _now: Date): ProjectedEntity {
+    const projected = createProjectedEntity(entity)
+    const ordered = schedule.orderedTasks(entity)
+    for (let i = anchoredSkipCount(entity, ordered); i < ordered.length; i++) {
+        applyTask(projected, ordered[i].task)
     }
-}
-
-export function projectFromCurrentState(snapshot: ProjectableSnapshot): ProjectedEntity {
-    const projectable = buildRemainingProjectable(snapshot)
-    return projectable ? projectEntity(projectable) : createProjectedEntity(snapshot)
+    return projected
 }
 
 function getRecipeInputsForOutput(outputItemId: number): RecipeInput[] | undefined {
@@ -346,19 +487,10 @@ function validateCraftTask(task: ServerContract.Types.task, projected: Projected
         let matched = false
         for (let ri = 0; ri < recipe.length; ri++) {
             const req = recipe[ri]
-            if ('itemId' in req) {
-                if (input.item_id.toNumber() === req.itemId) {
-                    groupedInputs[ri].push(input)
-                    matched = true
-                    break
-                }
-            } else {
-                const item = getItem(input.item_id)
-                if (item.category === req.category && item.tier === req.tier) {
-                    groupedInputs[ri].push(input)
-                    matched = true
-                    break
-                }
+            if (input.item_id.toNumber() === req.itemId) {
+                groupedInputs[ri].push(input)
+                matched = true
+                break
             }
         }
         if (!matched) throw new Error(RECIPE_INPUTS_INVALID)
@@ -389,15 +521,16 @@ function validateCraftTask(task: ServerContract.Types.task, projected: Projected
                 break
             }
         }
-        if (!found) throw new Error(SHIP_CARGO_NOT_LOADED)
+        if (!found) throw new Error(ENTITY_CARGO_NOT_LOADED)
     }
 }
 
 export function validateSchedule(entity: Projectable): void {
-    if (!entity.schedule || entity.schedule.tasks.length === 0) return
+    const ordered = schedule.orderedTasks(entity)
+    if (ordered.length === 0) return
 
     const projected = createProjectedEntity(entity)
-    for (const task of entity.schedule.tasks) {
+    for (const {task} of ordered) {
         if (task.type.toNumber() === TaskType.CRAFT) {
             validateCraftTask(task, projected)
         }
@@ -411,61 +544,44 @@ export function validateSchedule(entity: Projectable): void {
 export function projectEntityAt(entity: Projectable, now: Date): ProjectedEntity {
     const projected = createProjectedEntity(entity)
 
-    if (!entity.schedule || entity.schedule.tasks.length === 0) {
+    const ordered = schedule.orderedTasks(entity)
+    if (ordered.length === 0) {
         return projected
     }
 
-    for (let i = 0; i < entity.schedule.tasks.length; i++) {
-        const task = entity.schedule.tasks[i]
-        const taskComplete = schedule.isTaskComplete(entity, i, now)
-        const taskInProgress = schedule.isTaskInProgress(entity, i, now)
+    const nowMs = now.getTime()
+    const skip = anchoredSkipCount(entity, ordered)
+
+    for (let i = skip; i < ordered.length; i++) {
+        const {task, startsAt} = ordered[i]
+        const duration = task.duration.toNumber()
+        const elapsed = Math.min(
+            Math.max(0, Math.floor((nowMs - startsAt.getTime()) / 1000)),
+            duration
+        )
+        const taskComplete = elapsed >= duration
+        const taskInProgress = elapsed > 0 && elapsed < duration
 
         if (!taskComplete && !taskInProgress) {
-            break
+            continue
         }
 
-        const progress = taskInProgress
-            ? schedule.getTaskElapsed(entity, i, now) / task.duration.toNumber()
-            : undefined
+        const progress = taskInProgress ? elapsed / duration : undefined
 
         switch (task.type.toNumber()) {
             case TaskType.RECHARGE:
                 applyRechargeTask(projected, task, {complete: taskComplete, progress})
                 break
             case TaskType.TRAVEL:
+            case TaskType.WARP:
+            case TaskType.TRANSIT:
                 applyFlightTask(projected, task, {complete: taskComplete, progress})
                 break
-            case TaskType.LOAD:
-            case TaskType.UNWRAP:
-                if (taskComplete) applyAddCargoTask(projected, task)
-                break
-            case TaskType.UNLOAD:
-            case TaskType.WRAP:
-                if (taskComplete) applyRemoveCargoTask(projected, task)
-                break
-            case TaskType.GATHER:
-                if (taskComplete) applyGatherTask(projected, task, {complete: true})
-                break
-            case TaskType.CRAFT:
-                if (taskComplete) applyCraftTask(projected, task)
-                break
-            case TaskType.DEPLOY:
-                if (taskComplete) applyDeployTask(projected, task)
-                break
-            case TaskType.UNDEPLOY:
-            case TaskType.WRAP_ENTITY:
-            case TaskType.DEMOLISH:
+            default:
+                if (taskComplete) applyTask(projected, task)
                 break
         }
     }
 
     return projected
 }
-
-export function projectFromCurrentStateAt(
-    snapshot: ProjectableSnapshot,
-    now: Date
-): ProjectedEntity {
-    const projectable = buildRemainingProjectable(snapshot)
-    return projectable ? projectEntityAt(projectable, now) : createProjectedEntity(snapshot)
-}