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

package/src/travel/route-simulator.ts

@@ -0,0 +1,170 @@
+import type {UInt64Type} from '@wharfkit/antelope'
+import {PRECISION, TRAVEL_MAX_DURATION} from '../types'
+import {
+    calc_energyusage,
+    calc_group_flighttime,
+    calc_rechargetime,
+    distanceBetweenPoints,
+} from './travel'
+
+export interface RouteMoverInput {
+    ref: {entityType: string; entityId: UInt64Type}
+    hasMovement: boolean
+    engines?: {thrust: number; drain: number}
+    generator?: {capacity: number; recharge: number}
+    hauler?: {capacity: number; efficiency: number}
+    mass: number
+    energy: number
+    priorMobilityEnd: number
+    narrowBarrierEnd: number
+    /** Max end (seconds-from-now) over all this entity's lanes incl. worker/craft; gates recharges like the contract's all_lanes_end. Default 0. */
+    allLanesEnd?: number
+}
+
+export interface RouteLegSim {
+    from: {x: number; y: number}
+    to: {x: number; y: number}
+    distanceCells: number
+    energyCostByMover: Record<string, number>
+    rechargeBefore: boolean
+    rechargeSeconds: number
+    flightSeconds: number
+}
+
+export interface RouteSim {
+    legs: RouteLegSim[]
+    totalSeconds: number
+    reachable: boolean
+}
+
+export function simulateRoute(
+    movers: RouteMoverInput[],
+    waypoints: {x: number; y: number}[],
+    origin: {x: number; y: number},
+    recharge: boolean
+): RouteSim {
+    const totalThrust = movers
+        .filter((m) => m.hasMovement && m.engines)
+        .reduce((sum, m) => sum + m.engines!.thrust, 0)
+
+    const totalMass = movers.reduce((sum, m) => sum + m.mass, 0)
+
+    const haulCount = movers.filter((m) => !m.hasMovement).length
+
+    const pooledHaulCap = movers
+        .filter((m) => m.hasMovement && m.hauler)
+        .reduce((sum, m) => sum + m.hauler!.capacity, 0)
+
+    const weightedHaulEffNum = movers
+        .filter((m) => m.hasMovement && m.hauler)
+        .reduce((sum, m) => sum + m.hauler!.efficiency * m.hauler!.capacity, 0)
+
+    const energyByMover: Map<string, number> = new Map(
+        movers.map((m) => [String(m.ref.entityId), m.energy])
+    )
+
+    let reachable = true
+    const legs: RouteLegSim[] = []
+
+    const mobilityBarrier = movers
+        .filter((m) => m.hasMovement)
+        .reduce((mx, m) => Math.max(mx, m.priorMobilityEnd, m.narrowBarrierEnd), 0)
+
+    const rechargeFloor = movers
+        .filter((m) => m.hasMovement && m.generator)
+        .reduce((mx, m) => Math.max(mx, m.allLanesEnd ?? 0), 0)
+
+    let clock = 0
+
+    let from = origin
+    for (const to of waypoints) {
+        const distance = distanceBetweenPoints(from.x, from.y, to.x, to.y)
+        const distanceNum = Number(distance)
+        const distanceCells = distanceNum / PRECISION
+
+        const energyCostByMover: Record<string, number> = {}
+
+        for (const m of movers) {
+            if (!m.hasMovement || !m.engines) continue
+            const key = String(m.ref.entityId)
+            energyCostByMover[key] = Number(calc_energyusage(distance, m.engines.drain))
+        }
+
+        let rechargeBefore = false
+        let rechargeSeconds = 0
+
+        if (recharge) {
+            let maxDur = 0
+            for (const m of movers) {
+                if (!m.hasMovement || !m.generator) continue
+                const key = String(m.ref.entityId)
+                const curEnergy = energyByMover.get(key) ?? 0
+                const dur = Number(
+                    calc_rechargetime(m.generator.capacity, curEnergy, m.generator.recharge)
+                )
+                if (dur > maxDur) maxDur = dur
+            }
+            rechargeSeconds = maxDur
+            rechargeBefore = rechargeSeconds > 0
+
+            if (rechargeBefore) {
+                for (const m of movers) {
+                    if (!m.hasMovement || !m.generator) continue
+                    const key = String(m.ref.entityId)
+                    energyByMover.set(key, m.generator.capacity)
+                }
+                clock = Math.max(clock, rechargeFloor) + rechargeSeconds
+            }
+        }
+
+        for (const m of movers) {
+            if (!m.hasMovement || !m.engines) continue
+            const key = String(m.ref.entityId)
+            const cost = energyCostByMover[key] ?? 0
+            const curEnergy = energyByMover.get(key) ?? 0
+
+            if (recharge && m.generator) {
+                if (cost > m.generator.capacity) reachable = false
+            } else {
+                if (cost > curEnergy) reachable = false
+            }
+        }
+
+        const flightSeconds = Number(
+            calc_group_flighttime(
+                totalThrust,
+                haulCount,
+                pooledHaulCap,
+                weightedHaulEffNum,
+                totalMass,
+                distance
+            )
+        )
+
+        if (flightSeconds > TRAVEL_MAX_DURATION) reachable = false
+
+        for (const m of movers) {
+            if (!m.hasMovement || !m.engines) continue
+            const key = String(m.ref.entityId)
+            const cost = energyCostByMover[key] ?? 0
+            const curEnergy = energyByMover.get(key) ?? 0
+            energyByMover.set(key, Math.max(0, curEnergy - cost))
+        }
+
+        clock = Math.max(clock, mobilityBarrier) + flightSeconds
+
+        legs.push({
+            from,
+            to,
+            distanceCells,
+            energyCostByMover,
+            rechargeBefore,
+            rechargeSeconds,
+            flightSeconds,
+        })
+
+        from = to
+    }
+
+    return {legs, totalSeconds: clock, reachable}
+}

package/src/travel/travel.ts

@@ -14,7 +14,6 @@ import {
     type Checksum256,
     Int64,
     type Int64Type,
-    UInt16,
     UInt32,
     type UInt32Type,
     UInt64,
@@ -23,17 +22,30 @@ import {
 
 import type {ServerContract} from '../contracts'
 import {
+    BASE_HAUL_PENALTY_MILLI,
     BASE_ORBITAL_MASS,
     type CargoMassInfo,
     type Distance,
+    HAULER_EFFICIENCY_DENOM,
+    MASS_STAT_SCALE,
     MAX_ORBITAL_ALTITUDE,
     MIN_ORBITAL_ALTITUDE,
+    MIN_TRANSFER_DISTANCE_ORBITAL_VESSEL,
+    MIN_TRANSFER_DISTANCE_PLANETARY_STRUCTURE,
     PRECISION,
     type ShipLike,
     TaskType,
 } from '../types'
+import {EntityClass} from '../data/kind-registry'
 import {getItem} from '../data/catalog'
 import {hasSystem} from '../utils/system'
+import {WH} from '../derivation/wormhole'
+import * as scheduleModel from '../scheduling/schedule'
+import type {ScheduleData} from '../scheduling/schedule'
+
+function isPositionalTask(task: ServerContract.Types.task): boolean {
+    return task.type.equals(TaskType.TRAVEL) || task.type.equals(TaskType.TRANSIT)
+}
 
 export function calc_orbital_altitude(mass: number): number {
     if (mass <= BASE_ORBITAL_MASS) {
@@ -111,15 +123,16 @@ export function getInterpolatedPosition(
     taskIndex: number,
     taskProgress: number
 ): FloatPosition {
-    if (!entity.schedule || entity.schedule.tasks.length === 0) {
+    const tasks = mobilityTasks(entity)
+    if (tasks.length === 0) {
         return {x: Number(entity.coordinates.x), y: Number(entity.coordinates.y)}
     }
     if (taskIndex < 0) {
-        const settled = getFlightOrigin(entity, entity.schedule.tasks.length)
+        const settled = getFlightOrigin(entity, tasks.length)
         return {x: Number(settled.x), y: Number(settled.y)}
     }
-    const task = entity.schedule.tasks[taskIndex]
-    if (!task.type.equals(TaskType.TRAVEL) || !task.coordinates) {
+    const task = tasks[taskIndex]
+    if (!isPositionalTask(task) || !task.coordinates) {
         const origin = getFlightOrigin(entity, taskIndex)
         return {x: Number(origin.x), y: Number(origin.y)}
     }
@@ -176,14 +189,15 @@ export function calc_rechargetime(
     const cap = UInt32.from(capacity)
     const eng = UInt32.from(energy)
     if (eng.gte(cap)) return UInt32.zero
-    return cap.subtracting(eng).dividing(recharge)
+    const ticks = cap.subtracting(eng).dividing(recharge)
+    return ticks.equals(UInt32.zero) ? UInt32.from(1) : ticks
 }
 
 export function calc_ship_rechargetime(ship: ShipLike): UInt32 {
     if (!ship.generator) return UInt32.from(0)
     return calc_rechargetime(
         ship.generator.capacity,
-        ship.energy ?? UInt16.from(0),
+        ship.energy ?? UInt32.from(0),
         ship.generator.recharge
     )
 }
@@ -192,20 +206,46 @@ export function calc_flighttime(distance: UInt64Type, acceleration: number): UIn
     return UInt32.from(2 * Math.sqrt(Number(distance) / acceleration))
 }
 
+export function calc_travel_flighttime(distance: UInt64Type, acceleration: number): UInt32 {
+    const cruiseTransitionDistance = 2 * PRECISION
+    if (Number(distance) <= cruiseTransitionDistance) {
+        return calc_flighttime(distance, acceleration)
+    }
+
+    const cruiseVelocity = Math.sqrt(acceleration * cruiseTransitionDistance)
+    return UInt32.from(Number(distance) / cruiseVelocity + cruiseVelocity / acceleration)
+}
+
+export function calc_transit_duration(ax: number, ay: number, bx: number, by: number): UInt32 {
+    const distance = distanceBetweenPoints(ax, ay, bx, by)
+    return UInt32.from(Math.floor(distance.toNumber() / (PRECISION * WH.TRANSIT_SPEED)))
+}
+
+// The active entity's chosen loader lane (lowest slot), mirroring cargo.cpp lane selection.
+export function shipLoaderLane(ship: ShipLike): {thrust: number; mass: number} | undefined {
+    const lanes = ship.loader_lanes ?? []
+    if (lanes.length === 0) return undefined
+    let lowest = lanes[0]
+    for (const lane of lanes) {
+        if (Number(lane.slot_index) < Number(lowest.slot_index)) lowest = lane
+    }
+    return {thrust: Number(lowest.thrust), mass: Number(lowest.mass)}
+}
+
 export function calc_loader_flighttime(ship: ShipLike, mass: UInt64, altitude?: number): UInt32 {
     const z = altitude ?? ship.coordinates.z?.toNumber() ?? calc_orbital_altitude(Number(mass))
     return calc_flighttime(z, calc_loader_acceleration(ship, mass))
 }
 
 export function calc_loader_acceleration(ship: ShipLike, mass: UInt64): number {
-    const thrust = ship.loaders ? Number(ship.loaders.thrust) : 0
-    const loaderMass = ship.loaders ? Number(ship.loaders.mass) : 0
-    return calc_acceleration(thrust, Number(mass) + loaderMass)
+    const lane = shipLoaderLane(ship)
+    const thrust = lane ? lane.thrust : 0
+    return calc_acceleration(thrust, Number(mass))
 }
 
 export function calc_ship_flighttime(ship: ShipLike, mass: UInt64, distance: UInt64): UInt32 {
     const acceleration = calc_ship_acceleration(ship, mass)
-    return calc_flighttime(distance, acceleration)
+    return calc_travel_flighttime(distance, acceleration)
 }
 
 export function calc_ship_acceleration(ship: ShipLike, mass: UInt64): number {
@@ -214,7 +254,7 @@ export function calc_ship_acceleration(ship: ShipLike, mass: UInt64): number {
 }
 
 export function calc_acceleration(thrust: number, mass: number): number {
-    return (thrust / mass) * PRECISION
+    return (thrust / (mass * MASS_STAT_SCALE)) * PRECISION
 }
 
 export function calc_ship_mass(ship: ShipLike, cargos: CargoMassInfo[]): UInt64 {
@@ -222,8 +262,10 @@ export function calc_ship_mass(ship: ShipLike, cargos: CargoMassInfo[]): UInt64
 
     mass.add(ship.hullmass)
 
-    if (ship.loaders && ship.loaders.quantity.gt(UInt32.zero)) {
-        mass.add(ship.loaders.mass.multiplying(ship.loaders.quantity))
+    if (ship.loader_lanes && ship.loader_lanes.length > 0) {
+        for (const l of ship.loader_lanes) {
+            mass.add(UInt64.from(l.mass))
+        }
     }
 
     for (const cargo of cargos) {
@@ -234,8 +276,31 @@ export function calc_ship_mass(ship: ShipLike, cargos: CargoMassInfo[]): UInt64
     return mass
 }
 
+export function calc_group_flighttime(
+    totalThrust: number,
+    haulCount: number,
+    pooledHaulCap: number,
+    weightedHaulEffNum: number,
+    totalMass: number,
+    distance: UInt64Type
+): UInt32 {
+    const avgHaulEff = pooledHaulCap > 0 ? Math.trunc(weightedHaulEffNum / pooledHaulCap) : 0
+    let effectiveThrust = totalThrust
+    if (haulCount > 0) {
+        const penaltyMilli =
+            1000 +
+            Math.trunc(
+                (haulCount * BASE_HAUL_PENALTY_MILLI * (HAULER_EFFICIENCY_DENOM - avgHaulEff)) /
+                    HAULER_EFFICIENCY_DENOM
+            )
+        effectiveThrust = Math.trunc((totalThrust * 1000) / penaltyMilli)
+    }
+    const acceleration = calc_acceleration(effectiveThrust, totalMass)
+    return calc_travel_flighttime(distance, acceleration)
+}
+
 export function calc_energyusage(distance: UInt64Type, drain: UInt32Type): UInt32 {
-    return UInt64.from(distance).dividing(PRECISION).multiplying(drain)
+    return UInt64.from(distance).multiplying(drain).dividing(PRECISION)
 }
 
 export function calculateTransferTime(
@@ -258,10 +323,10 @@ export function calculateTransferTime(
         return UInt32.from(0)
     }
 
-    if (!ship.loaders) return UInt32.from(0)
-    mass = UInt64.from(mass).adding(ship.loaders.mass)
-    const transfer_time = calc_loader_flighttime(ship, mass)
-    return transfer_time.dividing(ship.loaders.quantity)
+    const lane = shipLoaderLane(ship)
+    if (!lane) return UInt32.from(0)
+    mass = UInt64.from(mass).adding(UInt64.from(lane.mass))
+    return calc_loader_flighttime(ship, mass)
 }
 
 export function calculateRefuelingTime(ship: ShipLike): UInt32 {
@@ -316,25 +381,22 @@ export function calculateLoadTimeBreakdown(
     let unloadTime = 0
     let loadTime = 0
 
-    if (mass_unload.gt(UInt64.zero) && ship.loaders) {
-        const totalMass = UInt64.from(mass_unload).adding(ship.loaders.mass)
+    const lane = shipLoaderLane(ship)
+
+    if (mass_unload.gt(UInt64.zero) && lane) {
+        const totalMass = UInt64.from(mass_unload).adding(UInt64.from(lane.mass))
         unloadTime = Number(calc_loader_flighttime(ship, totalMass))
     }
 
-    if (mass_load.gt(UInt64.zero) && ship.loaders) {
-        const totalMass = UInt64.from(mass_load).adding(ship.loaders.mass)
+    if (mass_load.gt(UInt64.zero) && lane) {
+        const totalMass = UInt64.from(mass_load).adding(UInt64.from(lane.mass))
         loadTime = Number(calc_loader_flighttime(ship, totalMass))
     }
 
-    const numLoaders = ship.loaders ? Number(ship.loaders.quantity) : 0
-    const totalTime = numLoaders > 0 ? (unloadTime + loadTime) / numLoaders : 0
-    const unloadTimePerLoader = numLoaders > 0 ? unloadTime / numLoaders : 0
-    const loadTimePerLoader = numLoaders > 0 ? loadTime / numLoaders : 0
-
     return {
-        unloadTime: unloadTimePerLoader,
-        loadTime: loadTimePerLoader,
-        totalTime,
+        unloadTime,
+        loadTime,
+        totalTime: unloadTime + loadTime,
         unloadMass: Number(mass_unload),
         loadMass: Number(mass_load),
     }
@@ -368,24 +430,16 @@ export function estimateTravelTime(
     let loadTime = UInt32.zero
     let unloadTime = UInt32.zero
 
-    if (
-        loadMass &&
-        UInt32.from(loadMass).gt(UInt32.zero) &&
-        ship.loaders &&
-        ship.loaders.quantity.gt(UInt32.zero)
-    ) {
-        const totalMass = UInt64.from(loadMass).adding(ship.loaders.mass)
-        loadTime = calc_loader_flighttime(ship, totalMass).dividing(ship.loaders.quantity)
+    const lane = shipLoaderLane(ship)
+
+    if (loadMass && UInt32.from(loadMass).gt(UInt32.zero) && lane) {
+        const totalMass = UInt64.from(loadMass).adding(UInt64.from(lane.mass))
+        loadTime = calc_loader_flighttime(ship, totalMass)
     }
 
-    if (
-        unloadMass &&
-        UInt32.from(unloadMass).gt(UInt32.zero) &&
-        ship.loaders &&
-        ship.loaders.quantity.gt(UInt32.zero)
-    ) {
-        const totalMass = UInt64.from(unloadMass).adding(ship.loaders.mass)
-        unloadTime = calc_loader_flighttime(ship, totalMass).dividing(ship.loaders.quantity)
+    if (unloadMass && UInt32.from(unloadMass).gt(UInt32.zero) && lane) {
+        const totalMass = UInt64.from(unloadMass).adding(UInt64.from(lane.mass))
+        unloadTime = calc_loader_flighttime(ship, totalMass)
     }
 
     return {
@@ -417,30 +471,51 @@ export function hasEnergyForDistance(ship: ShipLike, distance: UInt64Type): bool
     return UInt64.from(ship.energy ?? 0).gte(energyNeeded)
 }
 
+export interface TransferLoaderLane {
+    slot_index?: {toNumber(): number} | number
+    thrust: {toNumber(): number} | number
+    mass: {toNumber(): number} | number
+}
+
 export interface TransferEntity {
     location: {z?: {toNumber(): number} | number}
-    loaders?: {
-        thrust: {toNumber(): number} | number
-        mass: {toNumber(): number} | number
-        quantity: {toNumber(): number} | number
+    entityClass: EntityClass
+    loaderLanes?: TransferLoaderLane[]
+}
+
+function toNum(v: {toNumber(): number} | number | undefined): number {
+    if (v === undefined) return 0
+    return typeof v === 'number' ? v : v.toNumber()
+}
+
+// Mirrors cargo.cpp worker_lane_key_or_mobility: lowest-slot loader lane (display has no busy context).
+function chosenLoaderLane(entity: TransferEntity): TransferLoaderLane | undefined {
+    const lanes = entity.loaderLanes ?? []
+    if (lanes.length === 0) return undefined
+    let lowest = lanes[0]
+    for (const lane of lanes) {
+        if (toNum(lane.slot_index) < toNum(lowest.slot_index)) lowest = lane
     }
+    return lowest
 }
 
-export interface HasScheduleAndLocation {
+export interface HasScheduleAndLocation extends ScheduleData {
     coordinates: ServerContract.ActionParams.Type.coordinates
-    schedule?: ServerContract.Types.schedule
+}
+
+function mobilityTasks(entity: HasScheduleAndLocation): ServerContract.Types.task[] {
+    return scheduleModel.mobilityLane(entity)?.schedule.tasks ?? []
 }
 
 export function getFlightOrigin(
     entity: HasScheduleAndLocation,
     flightTaskIndex: number
 ): ServerContract.ActionParams.Type.coordinates {
-    if (!entity.schedule) return entity.coordinates
-
+    const tasks = mobilityTasks(entity)
     let origin = entity.coordinates
-    for (let i = 0; i < flightTaskIndex && i < entity.schedule.tasks.length; i++) {
-        const task = entity.schedule.tasks[i]
-        if (task.type.equals(TaskType.TRAVEL) && task.coordinates) {
+    for (let i = 0; i < flightTaskIndex && i < tasks.length; i++) {
+        const task = tasks[i]
+        if (isPositionalTask(task) && task.coordinates) {
             origin = task.coordinates
         }
     }
@@ -450,11 +525,10 @@ export function getFlightOrigin(
 export function getDestinationLocation(
     entity: HasScheduleAndLocation
 ): ServerContract.ActionParams.Type.coordinates | undefined {
-    if (!entity.schedule) return undefined
-
-    for (let i = entity.schedule.tasks.length - 1; i >= 0; i--) {
-        const task = entity.schedule.tasks[i]
-        if (task.type.equals(TaskType.TRAVEL) && task.coordinates) {
+    const tasks = mobilityTasks(entity)
+    for (let i = tasks.length - 1; i >= 0; i--) {
+        const task = tasks[i]
+        if (isPositionalTask(task) && task.coordinates) {
             return task.coordinates
         }
     }
@@ -467,16 +541,17 @@ export function getPositionAt(
     taskIndex: number,
     taskProgress: number
 ): ServerContract.ActionParams.Type.coordinates {
-    if (!entity.schedule || entity.schedule.tasks.length === 0) {
+    const tasks = mobilityTasks(entity)
+    if (tasks.length === 0) {
         return entity.coordinates
     }
     if (taskIndex < 0) {
-        return getFlightOrigin(entity, entity.schedule.tasks.length)
+        return getFlightOrigin(entity, tasks.length)
     }
 
-    const task = entity.schedule.tasks[taskIndex]
+    const task = tasks[taskIndex]
 
-    if (!task.type.equals(TaskType.TRAVEL) || !task.coordinates) {
+    if (!isPositionalTask(task) || !task.coordinates) {
         return getFlightOrigin(entity, taskIndex)
     }
 
@@ -490,68 +565,60 @@ export function getPositionAt(
     }
 }
 
-export function calc_transfer_duration(
-    source: TransferEntity,
-    dest: TransferEntity,
+export function minTransferDistance(entityClass: EntityClass): number {
+    return entityClass === EntityClass.OrbitalVessel
+        ? MIN_TRANSFER_DISTANCE_ORBITAL_VESSEL
+        : MIN_TRANSFER_DISTANCE_PLANETARY_STRUCTURE
+}
+
+// Mirrors cargo.cpp calc_onesided_duration: single active loader's thrust + mass, no ÷quantity.
+export function calc_onesided_duration(
+    loaderThrust: number,
+    loaderMass: number,
+    activeZ: number,
+    counterpartZ: number,
+    activeEntityClass: EntityClass,
+    counterpartEntityClass: EntityClass,
     cargoMass: number
 ): number {
-    if (cargoMass === 0) {
+    if (cargoMass === 0 || loaderThrust === 0) {
         return 0
     }
+    const rawDistance = Math.abs(activeZ - counterpartZ)
+    const minDistance = Math.max(
+        minTransferDistance(activeEntityClass),
+        minTransferDistance(counterpartEntityClass)
+    )
+    const distance = rawDistance < minDistance ? minDistance : rawDistance
+    const totalMass = cargoMass + loaderMass
+    const acceleration = calc_acceleration(loaderThrust, totalMass)
+    const flightTime = Math.floor(2 * Math.sqrt(distance / acceleration))
+    return flightTime === 0 ? 1 : flightTime
+}
 
-    let totalThrust = 0
-    let totalLoaderMass = 0
-    let totalQuantity = 0
-
-    if (source.loaders) {
-        const thrust =
-            typeof source.loaders.thrust === 'number'
-                ? source.loaders.thrust
-                : source.loaders.thrust.toNumber()
-        const mass =
-            typeof source.loaders.mass === 'number'
-                ? source.loaders.mass
-                : source.loaders.mass.toNumber()
-        const qty =
-            typeof source.loaders.quantity === 'number'
-                ? source.loaders.quantity
-                : source.loaders.quantity.toNumber()
-        totalThrust += thrust * qty
-        totalLoaderMass += mass * qty
-        totalQuantity += qty
-    }
-
-    if (dest.loaders) {
-        const thrust =
-            typeof dest.loaders.thrust === 'number'
-                ? dest.loaders.thrust
-                : dest.loaders.thrust.toNumber()
-        const mass =
-            typeof dest.loaders.mass === 'number' ? dest.loaders.mass : dest.loaders.mass.toNumber()
-        const qty =
-            typeof dest.loaders.quantity === 'number'
-                ? dest.loaders.quantity
-                : dest.loaders.quantity.toNumber()
-        totalThrust += thrust * qty
-        totalLoaderMass += mass * qty
-        totalQuantity += qty
-    }
-
-    if (totalThrust === 0 || totalQuantity === 0) {
+// Mirrors cargo.cpp: the active (loader-bearing) entity's chosen loader lane drives the duration.
+export function calc_transfer_duration(
+    source: TransferEntity,
+    dest: TransferEntity,
+    cargoMass: number
+): number {
+    const active = chosenLoaderLane(source) ? source : dest
+    const counterpart = active === source ? dest : source
+    const lane = chosenLoaderLane(active)
+    if (!lane) {
         return 0
     }
 
-    const sourceZ =
-        typeof source.location.z === 'number'
-            ? source.location.z
-            : (source.location.z?.toNumber() ?? 0)
-    const destZ =
-        typeof dest.location.z === 'number' ? dest.location.z : (dest.location.z?.toNumber() ?? 0)
-    const distance = Math.abs(sourceZ - destZ)
-
-    const totalMass = cargoMass + totalLoaderMass
-    const acceleration = calc_acceleration(totalThrust, totalMass)
-    const flightTime = 2 * Math.sqrt(distance / acceleration)
-
-    return Math.floor(flightTime / totalQuantity)
+    const activeZ = toNum(active.location.z)
+    const counterpartZ = toNum(counterpart.location.z)
+
+    return calc_onesided_duration(
+        toNum(lane.thrust),
+        toNum(lane.mass),
+        activeZ,
+        counterpartZ,
+        active.entityClass,
+        counterpart.entityClass,
+        cargoMass
+    )
 }