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

package/src/derivation/capabilities.ts

@@ -131,6 +131,17 @@ export function computeHaulerCapabilities(stats: Record<string, 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
 } {
@@ -160,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'
@@ -174,9 +187,10 @@ 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,
@@ -186,6 +200,7 @@ import {
     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) {
@@ -193,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:
@@ -258,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(
@@ -267,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
@@ -300,6 +319,11 @@ export function computeEntityCapabilities(
     let totalWarpRange = 0
     let hasWarp = false
 
+    let totalLauncherChargeRate = 0
+    let totalLauncherVelocity = 0
+    let totalLauncherDrain = 0
+    let hasLauncher = false
+
     let totalBatteryCapacity = 0
 
     const gathererLanes: GathererLaneEntry[] = []
@@ -317,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)
@@ -376,6 +401,19 @@ 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) {
             const caps = computeBatteryCapabilities(decodedStats)
             totalBatteryCapacity += applySlotMultiplierUint32(caps.capacity, amp)
@@ -392,7 +430,8 @@ export function computeEntityCapabilities(
     }
 
     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 = {
@@ -432,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/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'
 
@@ -383,6 +390,7 @@ export {
     computeContainerCapabilities,
     computeContainerT2Capabilities,
     computeWarpCapabilities,
+    computeLauncherCapabilities,
     computeBaseCapacity,
     computeEntityCapabilities,
     GATHERER_DEPTH_TABLE,
@@ -485,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),

package/src/nft/description.ts

@@ -62,6 +62,16 @@ export function computeBaseCapacityWarehouse(stats: bigint): number {
 
 export const computeEngineThrust = (vol: number): number => 400 + idiv(vol * 3, 4)
 export const computeEngineDrain = (thm: number): number => 2 * Math.max(30, 50 - idiv(thm, 70))
+export const ENGINE_DRAIN_BASE = 118
+export const ENGINE_DRAIN_REF_THRUST = 775
+export const ENGINE_DRAIN_REF_THM = 500
+
+export const computeTravelDrain = (totalThrust: number, avgThm: number): number => {
+    if (totalThrust <= 0) return 0
+    const num = ENGINE_DRAIN_BASE * ENGINE_DRAIN_REF_THRUST * computeEngineDrain(avgThm)
+    const den = totalThrust * computeEngineDrain(ENGINE_DRAIN_REF_THM)
+    return idiv(num, den)
+}
 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

package/src/resolution/resolve-item.test.ts

@@ -0,0 +1,37 @@
+import {expect, test} from 'bun:test'
+import {UInt16, UInt64} from '@wharfkit/antelope'
+import {resolveItem} from './resolve-item'
+import {encodeStats} from '../derivation/crafting'
+import {computeContainerCapabilities} from '../derivation/capabilities'
+import {
+    ITEM_EXTRACTOR_T1_PACKED,
+    ITEM_FACTORY_T1_PACKED,
+    ITEM_MASS_DRIVER_T1_PACKED,
+    ITEM_MASS_CATCHER_T1_PACKED,
+} from '../data/item-ids'
+
+function hullStats(strength: number, density: number, hardness: number): UInt64 {
+    return UInt64.from(encodeStats([strength, density, hardness]).toString())
+}
+
+const CONTAINER_ENTITIES = [
+    ['factory', ITEM_FACTORY_T1_PACKED],
+    ['extractor', ITEM_EXTRACTOR_T1_PACKED],
+    ['mass driver', ITEM_MASS_DRIVER_T1_PACKED],
+    ['mass catcher', ITEM_MASS_CATCHER_T1_PACKED],
+] as const
+
+for (const [label, itemId] of CONTAINER_ENTITIES) {
+    test(`resolveItem resolves ${label} hull capacity via container formula`, () => {
+        const stats = hullStats(300, 100, 400)
+        const resolved = resolveItem(UInt16.from(itemId), stats)
+        const hull = resolved.attributes?.find((g) => g.capability === 'Hull')
+        const capacity = hull?.attributes.find((a) => a.label === 'Capacity')?.value
+        const expected = computeContainerCapabilities({
+            strength: 300,
+            hardness: 400,
+            density: 100,
+        }).capacity
+        expect(capacity).toBe(expected)
+    })
+}

package/src/resolution/resolve-item.ts

@@ -39,6 +39,9 @@ import {
     ITEM_CONTAINER_T1_PACKED,
     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'
@@ -287,7 +290,9 @@ function hullCapsForEntity(
         case ITEM_WAREHOUSE_T1_PACKED:
             return computeWarehouseHullCapabilities(decoded)
         case ITEM_EXTRACTOR_T1_PACKED:
-            return computeShipHullCapabilities(decoded)
+        case ITEM_FACTORY_T1_PACKED:
+        case ITEM_MASS_DRIVER_T1_PACKED:
+        case ITEM_MASS_CATCHER_T1_PACKED:
         case ITEM_CONTAINER_T1_PACKED:
             return computeContainerCapabilities(decoded)
         case ITEM_CONTAINER_T2_PACKED:

package/src/scheduling/projection.ts

@@ -41,6 +41,7 @@ export interface ProjectedEntity {
     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[]
@@ -49,6 +50,7 @@ export interface ProjectedEntity {
     hasMovement(): boolean
     hasStorage(): boolean
     hasLoaders(): boolean
+    hasLauncher(): boolean
 
     capabilities(): EntityCapabilities
     state(): EntityState
@@ -64,6 +66,7 @@ export interface Projectable extends ScheduleData {
     gatherer_lanes?: ServerContract.Types.gatherer_lane[]
     crafter_lanes?: ServerContract.Types.crafter_lane[]
     hauler?: ServerContract.Types.hauler_stats
+    launcher?: ServerContract.Types.launcher_stats
     capacity?: UInt32
     cargo: ServerContract.Types.cargo_item[]
     cargomass: UInt32
@@ -91,6 +94,7 @@ interface ProjectedCaps {
     gathererLanes: ServerContract.Types.gatherer_lane[]
     crafterLanes: ServerContract.Types.crafter_lane[]
     hauler?: ServerContract.Types.hauler_stats
+    launcher?: ServerContract.Types.launcher_stats
 }
 
 function recomputeCaps(entity: Projectable): ProjectedCaps | undefined {
@@ -164,6 +168,13 @@ function recomputeCaps(entity: Projectable): ProjectedCaps | undefined {
         gathererLanes: (caps.gathererLanes ?? []).map(toGathererLane),
         crafterLanes: (caps.crafterLanes ?? []).map(toCrafterLane),
         hauler: caps.hauler ? ServerContract.Types.hauler_stats.from(caps.hauler) : undefined,
+        launcher: caps.launcher
+            ? ServerContract.Types.launcher_stats.from({
+                  charge_rate: caps.launcher.chargeRate,
+                  velocity: caps.launcher.velocity,
+                  drain: caps.launcher.drain,
+              })
+            : undefined,
     }
 }
 
@@ -180,6 +191,7 @@ export function createProjectedEntity(entity: Projectable): ProjectedEntity {
         entity.engines === undefined ||
         entity.generator === undefined ||
         entity.hauler === undefined ||
+        entity.launcher === undefined ||
         entity.capacity === undefined
     const caps = needsRecompute ? recomputeCaps(entity) : undefined
 
@@ -190,6 +202,7 @@ export function createProjectedEntity(entity: Projectable): ProjectedEntity {
     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)
@@ -203,6 +216,7 @@ export function createProjectedEntity(entity: Projectable): ProjectedEntity {
         engines,
         generator,
         hauler,
+        launcher,
         loaderLanes,
         gathererLanes,
         crafterLanes,
@@ -229,12 +243,17 @@ export function createProjectedEntity(entity: Projectable): ProjectedEntity {
             return this.loaderLanes.length > 0
         },
 
+        hasLauncher() {
+            return this.launcher !== undefined
+        },
+
         capabilities(): EntityCapabilities {
             return {
                 hullmass: this.shipMass,
                 capacity: this.capacity ? UInt32.from(this.capacity) : undefined,
                 engines: this.engines,
                 generator: this.generator,
+                launcher: this.launcher,
             }
         },
 

package/src/types/capabilities.ts

@@ -59,6 +59,7 @@ export interface EntityCapabilities {
     gatherer?: GathererStats
     crafter?: CrafterStats
     hauler?: ServerContract.Types.hauler_stats
+    launcher?: ServerContract.Types.launcher_stats
 }
 
 export interface EntityState {
@@ -92,3 +93,7 @@ export function capsHasMass(caps: EntityCapabilities): boolean {
 export function capsHasHauler(caps: EntityCapabilities): boolean {
     return caps.hauler !== undefined
 }
+
+export function capsHasLauncher(caps: EntityCapabilities): boolean {
+    return caps.launcher !== undefined
+}

package/src/types.ts

@@ -129,6 +129,7 @@ export type ModuleType =
     | 'storage'
     | 'hauler'
     | 'battery'
+    | 'catcher'
 
 export const RESOURCE_TIER_ADJECTIVES: Record<number, string> = {
     1: 'Crude',