@shipload/sdk 1.0.0-next.37 → 1.0.0-next.39

package/src/data/metadata.ts

@@ -197,8 +197,8 @@ export const itemMetadata: Record<number, ItemMetadata> = {
         color: '#B877FF',
     },
     10105: {
-        name: 'Storage',
-        description: 'Expands cargo capacity based on hull material quality.',
+        name: 'Cargo Bay',
+        description: 'Expanded cargo storage with reinforced internal holds.',
         color: '#8B7355',
     },
     10106: {
@@ -214,11 +214,15 @@ export const itemMetadata: Record<number, ItemMetadata> = {
         color: '#9be4ff',
     },
     10108: {
-        name: 'Battery',
-        description:
-            'Extends energy capacity. Stores additional charge produced by generators, letting builds chain more high-drain actions between recharges.',
+        name: 'Battery Bank',
+        description: 'Stores additional charge produced by generators.',
         color: '#4ADBFF',
     },
+    10109: {
+        name: 'Drive Coil',
+        description: 'Accelerates and launches cargo payloads toward a remote mass catcher.',
+        color: '#E86344',
+    },
 
     // === Entities (packed, T1) ===
     10200: {
@@ -247,6 +251,17 @@ export const itemMetadata: Record<number, ItemMetadata> = {
         description: 'Planetary fabrication facility with generator and crafter module slots.',
         color: '#7BA7D4',
     },
+    10205: {
+        name: 'Mass Driver',
+        description: 'Planetary launch platform with generator and drive coil module slots.',
+        color: '#E86344',
+    },
+    10206: {
+        name: 'Mass Catcher',
+        description:
+            'Planetary receiving platform with storage module slots; catches launched payloads.',
+        color: '#4AE898',
+    },
 
     // === Components (T2) ===
     20001: {
@@ -274,6 +289,8 @@ export const entityMetadata: Record<number, EntityMetadata> = {
     10202: {moduleSlotLabels: ['Loader', 'Storage', 'Storage', 'Storage', 'Storage']},
     10203: {moduleSlotLabels: ['Generator', 'Gatherer']},
     10204: {moduleSlotLabels: ['Generator', 'Crafter']},
+    10205: {moduleSlotLabels: ['Generator', 'Drive Coil']},
+    10206: {moduleSlotLabels: ['Storage', 'Storage', 'Storage']},
 }
 
 for (const item of items as Array<{id: number}>) {

package/src/data/recipes.json

@@ -450,11 +450,11 @@
     "outputMass": 960000,
     "inputs": [
       {
-        "itemId": 10008,
+        "itemId": 10009,
         "quantity": 300
       },
       {
-        "itemId": 10009,
+        "itemId": 10006,
         "quantity": 300
       }
     ],
@@ -462,7 +462,7 @@
       {
         "sources": [
           {
-            "inputIndex": 1,
+            "inputIndex": 0,
             "statIndex": 0
           }
         ]
@@ -470,8 +470,8 @@
       {
         "sources": [
           {
-            "inputIndex": 0,
-            "statIndex": 1
+            "inputIndex": 1,
+            "statIndex": 0
           }
         ]
       }

package/src/derivation/capabilities.test.ts

@@ -4,11 +4,16 @@ import {
     computeGathererCapabilities,
     computeCrafterCapabilities,
     computeLoaderCapabilities,
+    computeBaseCapacity,
+    computeContainerCapabilities,
 } from './capabilities'
 import {applySlotMultiplier, U16_MAX} from '../entities/slot-multiplier'
 import {encodeStats} from './crafting'
 import {
     ITEM_EXTRACTOR_T1_PACKED,
+    ITEM_FACTORY_T1_PACKED,
+    ITEM_MASS_DRIVER_T1_PACKED,
+    ITEM_MASS_CATCHER_T1_PACKED,
     ITEM_GATHERER_T1,
     ITEM_CRAFTER_T1,
     ITEM_LOADER_T1,
@@ -20,14 +25,27 @@ function makeGathererStats(strength: number, tolerance: number, conductivity: nu
     return encodeStats([strength, tolerance, conductivity, 0])
 }
 
-function makeCrafterStats(reactivity: number, fineness: number): bigint {
-    return encodeStats([reactivity, fineness])
+function makeCrafterStats(reactivity: number, conductivity: number): bigint {
+    return encodeStats([reactivity, conductivity])
 }
 
 function makeLoaderStats(insulation: number, plasticity: number): bigint {
     return encodeStats([insulation, plasticity])
 }
 
+test('computeBaseCapacity uses container formula for all container-class entities', () => {
+    const stats = {strength: 300, hardness: 400, density: 100}
+    const expected = computeContainerCapabilities(stats).capacity
+    for (const itemId of [
+        ITEM_EXTRACTOR_T1_PACKED,
+        ITEM_FACTORY_T1_PACKED,
+        ITEM_MASS_DRIVER_T1_PACKED,
+        ITEM_MASS_CATCHER_T1_PACKED,
+    ]) {
+        expect(computeBaseCapacity(itemId, stats)).toBe(expected)
+    }
+})
+
 test('computeEntityCapabilities emits gathererLanes alongside legacy gatherer sum', () => {
     // Two gatherers with distinct stats in separate slots, amp=100 for both
     const gathStats1 = makeGathererStats(300, 200, 400)
@@ -92,7 +110,7 @@ test('computeEntityCapabilities emits crafterLanes alongside legacy crafter sum'
     expect(result.crafterLanes!.length).toBe(1)
     expect(result.crafterLanes![0].slotIndex).toBe(0)
 
-    const caps = computeCrafterCapabilities({reactivity: 400, fineness: 300})
+    const caps = computeCrafterCapabilities({reactivity: 400, conductivity: 300})
     const expectedSpeed = applySlotMultiplier(caps.speed, 120)
     expect(result.crafterLanes![0].speed).toBe(expectedSpeed)
     expect(result.crafterLanes![0].drain).toBe(caps.drain)

package/src/derivation/capabilities.ts

@@ -107,11 +107,11 @@ export function computeCrafterCapabilities(stats: Record<string, number>): {
     drain: number
 } {
     const rea = stats.reactivity
-    const fin = stats.fineness
+    const con = stats.conductivity
 
     return {
         speed: 100 + Math.floor((rea * 4) / 5),
-        drain: Math.max(5, 30 - Math.floor(fin / 33)),
+        drain: Math.max(5, 30 - Math.floor(con / 33)),
     }
 }
 
@@ -131,23 +131,39 @@ export function computeHaulerCapabilities(stats: Record<string, number>): {
     }
 }
 
-export function computeStorageCapabilities(
-    stats: Record<string, number>,
-    baseCapacity: number
-): {
-    capacityBonus: number
+export function computeLauncherCapabilities(
+    stats: {charge_rate: number; velocity: number; drain: number},
+    amp = 100
+): {chargeRate: number; velocity: number; drain: number} {
+    return {
+        chargeRate: Math.floor((stats.charge_rate * amp) / 100),
+        velocity: Math.floor((stats.velocity * amp) / 100),
+        drain: stats.drain,
+    }
+}
+
+export function computeStorageCapabilities(stats: Record<string, number>): {
+    capacity: number
 } {
-    const strength = stats.strength
-    const density = stats.density
-    const hardness = stats.hardness
-    const cohesion = stats.cohesion
+    const strength = stats.strength ?? 0
+    const density = stats.density ?? 0
+    const hardness = stats.hardness ?? 0
+    const cohesion = stats.cohesion ?? 0
 
     const statSum = strength + density + hardness + cohesion
-    const capacityBonus = Math.floor(
-        (baseCapacity * (10 + Math.floor((statSum * 10) / 2997))) / 100
-    )
+    return {capacity: 10_000_000 + Math.floor((statSum * 50_000_000) / 3996)}
+}
 
-    return {capacityBonus}
+export function computeBatteryCapabilities(stats: Record<string, number>): {
+    capacity: number
+} {
+    const volatility = stats.volatility ?? 0
+    const thermal = stats.thermal ?? 0
+    const plasticity = stats.plasticity ?? 0
+    const insulation = stats.insulation ?? 0
+
+    const statSum = volatility + thermal + plasticity + insulation
+    return {capacity: 2_500 + Math.floor((statSum * 7_500) / 3996)}
 }
 
 import {
@@ -155,6 +171,8 @@ import {
     ITEM_CONTAINER_T2_PACKED,
     ITEM_EXTRACTOR_T1_PACKED,
     ITEM_FACTORY_T1_PACKED,
+    ITEM_MASS_CATCHER_T1_PACKED,
+    ITEM_MASS_DRIVER_T1_PACKED,
     ITEM_SHIP_T1_PACKED,
     ITEM_WAREHOUSE_T1_PACKED,
 } from '../data/item-ids'
@@ -169,17 +187,20 @@ import {
     MODULE_CRAFTER,
     MODULE_HAULER,
     MODULE_WARP,
+    MODULE_LAUNCHER,
 } from '../capabilities/modules'
 import {getItem} from '../data/catalog'
-import {decodeCraftedItemStats} from './crafting'
+import {decodeCraftedItemStats, decodeStat} from './crafting'
 import {
     applySlotMultiplier,
+    applySlotMultiplierUint32,
     clampUint16,
     clampUint32,
     getSlotAmp,
     type InstalledModule,
 } from '../entities/slot-multiplier'
 import type {EntitySlot} from '../data/recipes-runtime'
+import {computeTravelDrain} from '../nft/description'
 
 export function computeBaseCapacity(itemId: number, stats: Record<string, number>): number {
     switch (itemId) {
@@ -187,6 +208,8 @@ export function computeBaseCapacity(itemId: number, stats: Record<string, number
             return computeShipHullCapabilities(stats).capacity
         case ITEM_EXTRACTOR_T1_PACKED:
         case ITEM_FACTORY_T1_PACKED:
+        case ITEM_MASS_DRIVER_T1_PACKED:
+        case ITEM_MASS_CATCHER_T1_PACKED:
         case ITEM_CONTAINER_T1_PACKED:
             return computeContainerCapabilities(stats).capacity
         case ITEM_WAREHOUSE_T1_PACKED:
@@ -252,6 +275,7 @@ export interface ComputedCapabilities {
     crafterLanes?: CrafterLaneEntry[]
     hauler?: {capacity: number; efficiency: number; drain: number}
     warp?: {range: number}
+    launcher?: {chargeRate: number; velocity: number; drain: number}
 }
 
 export function computeEntityCapabilities(
@@ -261,7 +285,8 @@ export function computeEntityCapabilities(
     layout: EntitySlot[]
 ): ComputedCapabilities {
     let totalThrust = 0
-    let totalEngineDrain = 0
+    let totalEngineThm = 0
+    let engineCount = 0
     let hasEngine = false
 
     let totalGenCapacity = 0
@@ -278,7 +303,7 @@ export function computeEntityCapabilities(
     let maxGathDepth = 0
     let hasGatherer = false
 
-    let totalStorageBonus = 0
+    let totalStorageCapacity = 0
     const baseCapacity = computeBaseCapacity(itemId, stats)
     let installedModuleMass = 0
 
@@ -294,8 +319,12 @@ export function computeEntityCapabilities(
     let totalWarpRange = 0
     let hasWarp = false
 
-    let totalBatteryStatSum = 0
-    let batteryCount = 0
+    let totalLauncherChargeRate = 0
+    let totalLauncherVelocity = 0
+    let totalLauncherDrain = 0
+    let hasLauncher = false
+
+    let totalBatteryCapacity = 0
 
     const gathererLanes: GathererLaneEntry[] = []
     const crafterLanes: CrafterLaneEntry[] = []
@@ -312,7 +341,8 @@ export function computeEntityCapabilities(
             hasEngine = true
             const caps = computeEngineCapabilities(decodedStats)
             totalThrust += applySlotMultiplier(caps.thrust, amp)
-            totalEngineDrain += caps.drain
+            totalEngineThm += decodedStats.thermal ?? 0
+            engineCount += 1
         } else if (modType === MODULE_GENERATOR) {
             hasGenerator = true
             const caps = computeGeneratorCapabilities(decodedStats)
@@ -346,8 +376,8 @@ export function computeEntityCapabilities(
                 outputPct: amp,
             })
         } else if (modType === MODULE_STORAGE) {
-            const caps = computeStorageCapabilities(decodedStats, baseCapacity)
-            totalStorageBonus += caps.capacityBonus
+            const caps = computeStorageCapabilities(decodedStats)
+            totalStorageCapacity += applySlotMultiplierUint32(caps.capacity, amp)
         } else if (modType === MODULE_CRAFTER) {
             hasCrafter = true
             const caps = computeCrafterCapabilities(decodedStats)
@@ -371,29 +401,37 @@ export function computeEntityCapabilities(
             hasWarp = true
             const caps = computeWarpCapabilities(decodedStats)
             totalWarpRange += applySlotMultiplier(caps.range, amp)
+        } else if (modType === MODULE_LAUNCHER) {
+            hasLauncher = true
+            const caps = computeLauncherCapabilities(
+                {
+                    charge_rate: decodedStats.charge_rate ?? decodeStat(mod.stats, 0),
+                    velocity: decodedStats.velocity ?? decodeStat(mod.stats, 1),
+                    drain: decodedStats.drain ?? decodeStat(mod.stats, 2),
+                },
+                amp
+            )
+            totalLauncherChargeRate = clampUint16(totalLauncherChargeRate + caps.chargeRate)
+            totalLauncherVelocity = clampUint16(totalLauncherVelocity + caps.velocity)
+            totalLauncherDrain = clampUint16(totalLauncherDrain + caps.drain)
         } else if (modType === MODULE_BATTERY) {
-            batteryCount++
-            const vol = decodedStats.volatility ?? 0
-            const thm = decodedStats.thermal ?? 0
-            const pla = decodedStats.plasticity ?? 0
-            const ins = decodedStats.insulation ?? 0
-            totalBatteryStatSum += vol + thm + pla + ins
+            const caps = computeBatteryCapabilities(decodedStats)
+            totalBatteryCapacity += applySlotMultiplierUint32(caps.capacity, amp)
         }
     }
 
-    if (hasGenerator && batteryCount > 0) {
-        const genCapBase = totalGenCapacity
-        const bonusPctNum = 10 * batteryCount + Math.floor((totalBatteryStatSum * 10) / 2997)
-        totalGenCapacity += Math.floor((genCapBase * bonusPctNum) / 100)
+    if (hasGenerator && totalBatteryCapacity > 0) {
+        totalGenCapacity += totalBatteryCapacity
     }
 
     const result: ComputedCapabilities = {
         hullmass: computeBaseHullmass(stats) + installedModuleMass,
-        capacity: baseCapacity + totalStorageBonus,
+        capacity: clampUint32(baseCapacity + totalStorageCapacity),
     }
 
     if (hasEngine) {
-        result.engines = {thrust: totalThrust, drain: totalEngineDrain}
+        const avgThm = engineCount > 0 ? Math.trunc(totalEngineThm / engineCount) : 0
+        result.engines = {thrust: totalThrust, drain: computeTravelDrain(totalThrust, avgThm)}
     }
     if (hasGenerator) {
         result.generator = {
@@ -433,6 +471,13 @@ export function computeEntityCapabilities(
     if (hasWarp) {
         result.warp = {range: totalWarpRange}
     }
+    if (hasLauncher) {
+        result.launcher = {
+            chargeRate: totalLauncherChargeRate,
+            velocity: totalLauncherVelocity,
+            drain: totalLauncherDrain,
+        }
+    }
 
     return result
 }

package/src/entities/makers.ts

@@ -142,6 +142,13 @@ export function makeEntity(packedItemId: number, state: EntityStateInput): Entit
         if (caps.generator) info.generator = caps.generator
         if (caps.hauler) info.hauler = caps.hauler
         if (caps.warp) info.warp = caps.warp
+        if (caps.launcher) {
+            info.launcher = ServerContract.Types.launcher_stats.from({
+                charge_rate: caps.launcher.chargeRate,
+                velocity: caps.launcher.velocity,
+                drain: caps.launcher.drain,
+            })
+        }
 
         info.gatherer_lanes = (caps.gathererLanes ?? []).map((l) =>
             ServerContract.Types.gatherer_lane.from({

package/src/entities/slot-multiplier.ts

@@ -34,6 +34,10 @@ export function applySlotMultiplier(value: number, outputPct: number): number {
     return clampUint16(Math.floor((value * outputPct) / 100))
 }
 
+export function applySlotMultiplierUint32(value: number, outputPct: number): number {
+    return clampUint32(Math.floor((value * outputPct) / 100))
+}
+
 export function getSlotAmp(layout: EntitySlot[], slotIndex: number): number {
     return layout[slotIndex]?.outputPct ?? 100
 }

package/src/index-module.ts

@@ -62,7 +62,14 @@ export type {
     ScheduledBuild,
     Reservation,
 } from './managers'
-export type {EntityRefInput} from './managers/actions'
+export type {
+    EntityRefInput,
+    LaunchNumericInput,
+    LaunchQuote,
+    LaunchQuoteCatcher,
+    LaunchQuoteLauncher,
+    LaunchStatsInput,
+} from './managers/actions'
 export type {WrapDeposit} from './managers/nft'
 export {resolveLockedAmount} from './managers/nft'
 
@@ -191,7 +198,7 @@ export type {
     HasScheduleAndLocation,
 } from './travel/travel'
 
-export {planRoute, sdkSystemGraph} from './travel/route-planner'
+export {planRoute, sdkSystemGraph, MAX_LEGS} from './travel/route-planner'
 export type {
     Coord,
     Neighbor,
@@ -379,9 +386,11 @@ export {
     computeCrafterCapabilities,
     computeWarehouseHullCapabilities,
     computeStorageCapabilities,
+    computeBatteryCapabilities,
     computeContainerCapabilities,
     computeContainerT2Capabilities,
     computeWarpCapabilities,
+    computeLauncherCapabilities,
     computeBaseCapacity,
     computeEntityCapabilities,
     GATHERER_DEPTH_TABLE,
@@ -484,6 +493,10 @@ export {
     computeBaseCapacityWarehouse,
     computeEngineThrust,
     computeEngineDrain,
+    computeTravelDrain,
+    ENGINE_DRAIN_BASE,
+    ENGINE_DRAIN_REF_THRUST,
+    ENGINE_DRAIN_REF_THM,
     computeGeneratorCap,
     computeGeneratorRech,
     computeGathererYield,

package/src/managers/actions.ts

@@ -17,9 +17,144 @@ import {
     type UInt64Type,
 } from '@wharfkit/antelope'
 import {BaseManager} from './base'
-import type {CoordinatesType} from '../types'
+import {Coordinates, PRECISION, type CoordinatesType} from '../types'
 import {ServerContract} from '../contracts'
 import {ATOMICASSETS_ABI, SHIPLOAD_COLLECTION} from '../nft/atomicassets'
+import {getItem} from '../data/catalog'
+
+const CHARGE_K = 1n
+const ENERGY_DIVISOR = 1_000_000n
+const UINT32_MAX = 4_294_967_295
+const UINT32_MAX_BIGINT = 4_294_967_295n
+const UINT32_MOD = 4_294_967_296n
+const UINT64_MAX = 18_446_744_073_709_551_615n
+const PRECISION_BIGINT = BigInt(PRECISION)
+
+export type LaunchNumericInput =
+    | number
+    | bigint
+    | string
+    | {toNumber(): number}
+    | {toString(): string}
+
+export interface LaunchStatsInput {
+    charge_rate?: LaunchNumericInput
+    chargeRate?: LaunchNumericInput
+    velocity: LaunchNumericInput
+    drain: LaunchNumericInput
+}
+
+export interface LaunchQuoteLauncher {
+    coordinates: CoordinatesType
+    launcher: LaunchStatsInput
+    generator?: {capacity: LaunchNumericInput}
+}
+
+export interface LaunchQuoteCatcher {
+    coordinates: CoordinatesType
+}
+
+export interface LaunchQuote {
+    chargeTime: number
+    flightTime: number
+    arrival: Date
+    energyCost: number
+    maxReach: bigint
+}
+
+function toNumber(value: LaunchNumericInput): number {
+    if (typeof value === 'number') return Math.trunc(value)
+    if (typeof value === 'bigint') return Number(value)
+    if (typeof value === 'string') return Number(value)
+    if ('toNumber' in value && typeof value.toNumber === 'function') return value.toNumber()
+    return Number(value.toString())
+}
+
+function requiredNumber(value: LaunchNumericInput | undefined, label: string): number {
+    if (value === undefined) throw new Error(`launch quote requires ${label}`)
+    return toNumber(value)
+}
+
+function toBigInt(value: LaunchNumericInput | undefined): bigint {
+    if (value === undefined) return 0n
+    if (typeof value === 'bigint') return value
+    if (typeof value === 'number') return BigInt(Math.trunc(value))
+    if (typeof value === 'string') return BigInt(value)
+    return BigInt(value.toString())
+}
+
+function saturatingMul(lhs: bigint, rhs: bigint): bigint {
+    if (lhs !== 0n && rhs > UINT64_MAX / lhs) {
+        return UINT64_MAX
+    }
+    return lhs * rhs
+}
+
+function clampLaunchResult(value: bigint): number {
+    if (value < 1n) return 1
+    if (value > UINT32_MAX_BIGINT) return UINT32_MAX
+    return Number(value)
+}
+
+function toUint32(value: bigint): bigint {
+    return value % UINT32_MOD
+}
+
+function calcDistance(origin: CoordinatesType, destination: CoordinatesType): bigint {
+    const a = Coordinates.from(origin)
+    const b = Coordinates.from(destination)
+    const dx = toNumber(a.x) - toNumber(b.x)
+    const dy = toNumber(a.y) - toNumber(b.y)
+    return BigInt(Math.trunc(Math.sqrt(dx * dx + dy * dy) * PRECISION))
+}
+
+function calcCargoItemMassUint32(item: ServerContract.ActionParams.Type.cargo_item): bigint {
+    let mass = toUint32(BigInt(getItem(item.item_id).mass) * toUint32(toBigInt(item.quantity)))
+
+    for (const mod of item.modules) {
+        if (mod.installed) {
+            mass = toUint32(mass + BigInt(getItem(mod.installed.item_id).mass))
+        }
+    }
+
+    return mass
+}
+
+function calcPayloadMass(items: ServerContract.ActionParams.Type.cargo_item[]): bigint {
+    let mass = 0n
+    for (const item of items) {
+        mass = toUint32(mass + calcCargoItemMassUint32(item))
+    }
+    return mass
+}
+
+function calcChargeTime(chargeRate: number, mass: bigint): number {
+    const rate = BigInt(chargeRate || 1)
+    return clampLaunchResult((mass * CHARGE_K) / rate)
+}
+
+function calcFlightTime(velocity: number, distance: bigint): number {
+    const v = BigInt(velocity || 1)
+    return clampLaunchResult(distance / (v * PRECISION_BIGINT))
+}
+
+function calcLaunchEnergy(drain: number, mass: bigint, distance: bigint): number {
+    const e =
+        saturatingMul(saturatingMul(mass, distance / PRECISION_BIGINT), BigInt(drain)) /
+        ENERGY_DIVISOR
+    return clampLaunchResult(e)
+}
+
+function calcMaxReach(energyBudget: bigint, mass: bigint, drain: number): bigint {
+    if (energyBudget < 1n) return 0n
+    if (energyBudget >= UINT32_MAX_BIGINT || mass === 0n || drain === 0) return UINT64_MAX
+
+    const numerator = (energyBudget + 1n) * ENERGY_DIVISOR - 1n
+    const denominator = mass * BigInt(drain)
+    const distanceUnits = numerator / denominator
+    const maxDistance = distanceUnits * PRECISION_BIGINT + (PRECISION_BIGINT - 1n)
+    return maxDistance > UINT64_MAX ? UINT64_MAX : maxDistance
+}
 
 export type EntityRefInput = {
     entityType: NameType
@@ -166,6 +301,46 @@ export class ActionsManager extends BaseManager {
         })
     }
 
+    launch(
+        launcherId: UInt64Type,
+        catcherId: UInt64Type,
+        items: ServerContract.ActionParams.Type.cargo_item[]
+    ): Action {
+        return this.server.action('launch', {
+            launcher_id: UInt64.from(launcherId),
+            catcher_id: UInt64.from(catcherId),
+            items,
+        })
+    }
+
+    getLaunchQuote(
+        launcher: LaunchQuoteLauncher,
+        catcher: LaunchQuoteCatcher,
+        items: ServerContract.ActionParams.Type.cargo_item[],
+        start = new Date()
+    ): LaunchQuote {
+        const chargeRate = requiredNumber(
+            launcher.launcher.charge_rate ?? launcher.launcher.chargeRate,
+            'launcher charge rate'
+        )
+        const velocity = requiredNumber(launcher.launcher.velocity, 'launcher velocity')
+        const drain = requiredNumber(launcher.launcher.drain, 'launcher drain')
+        const mass = calcPayloadMass(items)
+        const distance = calcDistance(launcher.coordinates, catcher.coordinates)
+        const chargeTime = calcChargeTime(chargeRate, mass)
+        const flightTime = calcFlightTime(velocity, distance)
+        const energyCost = calcLaunchEnergy(drain, mass, distance)
+        const maxReach = calcMaxReach(toBigInt(launcher.generator?.capacity), mass, drain)
+
+        return {
+            chargeTime,
+            flightTime,
+            arrival: new Date(start.getTime() + (chargeTime + flightTime) * 1000),
+            energyCost,
+            maxReach,
+        }
+    }
+
     foundCompany(account: NameType, name: string): Action {
         return this.platform.action('foundcompany', {
             account: Name.from(account),