@shipload/sdk 1.0.0-next.5 → 1.0.0-next.51

package/src/nft/description.ts

@@ -4,6 +4,7 @@ import {
     MODULE_ENGINE,
     MODULE_GATHERER,
     MODULE_GENERATOR,
+    MODULE_BATTERY,
     MODULE_HAULER,
     MODULE_LOADER,
     MODULE_STORAGE,
@@ -14,17 +15,25 @@ import {
     ITEM_CONTAINER_T2_PACKED,
     ITEM_CRAFTER_T1,
     ITEM_ENGINE_T1,
+    ITEM_EXTRACTOR_T1_PACKED,
+    ITEM_FACTORY_T1_PACKED,
     ITEM_GATHERER_T1,
+    ITEM_GATHERER_T2,
     ITEM_GENERATOR_T1,
+    ITEM_HAULER_SHIP_T2_PACKED,
     ITEM_HAULER_T1,
+    ITEM_HAULER_T2,
+    ITEM_BATTERY_T1,
+    ITEM_LAUNCHER_T1,
     ITEM_LOADER_T1,
+    ITEM_PROSPECTOR_T2_PACKED,
     ITEM_SHIP_T1_PACKED,
     ITEM_STORAGE_T1,
     ITEM_WAREHOUSE_T1_PACKED,
     ITEM_WARP_T1,
 } from '../data/item-ids'
 import {decodeStat} from '../derivation/crafting'
-import {gathererDepthForTier} from '../entities/ship-deploy'
+import {gathererDepthForTier} from '../derivation/capabilities'
 import {getItem} from '../data/catalog'
 
 function idiv(a: number, b: number): number {
@@ -33,48 +42,83 @@ function idiv(a: number, b: number): number {
 
 export function computeBaseHullmass(stats: bigint): number {
     const density = decodeStat(stats, 1)
-    return 25000 + 75 * density
+    return 100000 - 75 * density
 }
 
 export function computeBaseCapacityShip(stats: bigint): number {
-    const s = decodeStat(stats, 0) + decodeStat(stats, 2) + decodeStat(stats, 3)
-    return Math.floor(1_000_000 * 10 ** (s / 2997))
+    const s = decodeStat(stats, 0) + decodeStat(stats, 2)
+    return Math.floor(5_000_000 * 6 ** (s / 1998))
+}
+
+export function computeBaseCapacityContainer(stats: bigint): number {
+    const s = decodeStat(stats, 0) + decodeStat(stats, 2)
+    return Math.floor(22_000_000 * 6 ** (s / 1998))
 }
 
 export function computeBaseCapacityWarehouse(stats: bigint): number {
-    const s = decodeStat(stats, 0) + decodeStat(stats, 2) + decodeStat(stats, 3)
-    return Math.floor(20_000_000 * 10 ** (s / 2997))
+    const s = decodeStat(stats, 0) + decodeStat(stats, 2)
+    return Math.floor(100_000_000 * 6 ** (s / 1998))
 }
 
 export const computeEngineThrust = (vol: number): number => 400 + idiv(vol * 3, 4)
-export const computeEngineDrain = (thm: number): number => Math.max(30, 50 - idiv(thm, 70))
-export const computeGeneratorCap = (com: number): number => 300 + idiv(com, 6)
-export const computeGeneratorRech = (fin: number): number => 1 + idiv(fin * 3, 1000)
+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 => 1300 + idiv(com, 2)
+export const computeGeneratorRech = (fin: number): number => 2 * (1 + idiv(fin * 3, 1000))
 export const computeGathererYield = (str: number): number => 200 + str
 export const computeGathererDrain = (con: number): number =>
-    Math.max(250, 1250 - idiv(con * 25, 20))
+    2 * Math.max(250, 1250 - idiv(con * 25, 20))
 export const computeGathererDepth = (tol: number, tier: number): number =>
     gathererDepthForTier(tol, tier)
-export const computeGathererSpeed = (ref: number): number => 100 + idiv(ref * 4, 5)
 export const computeLoaderMass = (ins: number): number => Math.max(200, 2000 - ins * 2)
-export const computeLoaderThrust = (pla: number): number => 1 + idiv(pla, 500)
+export const computeLoaderThrust = (pla: number): number => 1 + idiv(pla * pla, 10000)
 export const computeCrafterSpeed = (rea: number): number => 100 + idiv(rea * 4, 5)
 export const computeCrafterDrain = (fin: number): number => Math.max(5, 30 - idiv(fin, 33))
-export const computeHaulerCapacity = (fin: number): number => Math.max(1, 1 + idiv(fin, 400))
+export const computeHaulerCapacity = (fin: number, tier: number): number =>
+    Math.max(tier, tier + idiv(fin, 400))
 export const computeHaulerEfficiency = (con: number): number => 2000 + con * 6
 export const computeHaulerDrain = (com: number): number => Math.max(3, 15 - idiv(com, 80))
 export const computeWarpRange = (stat: number): number => 100 + stat * 3
+export const computeCargoBayCapacity = (
+    strength: number,
+    density: number,
+    hardness: number,
+    cohesion: number
+): number => 10_000_000 + idiv((strength + density + hardness + cohesion) * 50_000_000, 3996)
+export const computeBatteryBankCapacity = (
+    volatility: number,
+    thermal: number,
+    plasticity: number,
+    insulation: number
+): number => 2_500 + idiv((volatility + thermal + plasticity + insulation) * 7_500, 3996)
 
 export function entityDisplayName(itemId: number): string {
     switch (itemId) {
         case ITEM_SHIP_T1_PACKED:
-            return 'Ship'
+            return 'Roustabout'
         case ITEM_WAREHOUSE_T1_PACKED:
             return 'Warehouse'
+        case ITEM_EXTRACTOR_T1_PACKED:
+            return 'Mining Rig'
+        case ITEM_FACTORY_T1_PACKED:
+            return 'Factory'
         case ITEM_CONTAINER_T1_PACKED:
             return 'Container'
         case ITEM_CONTAINER_T2_PACKED:
             return 'Container'
+        case ITEM_PROSPECTOR_T2_PACKED:
+            return 'Prospector'
+        case ITEM_HAULER_SHIP_T2_PACKED:
+            return 'Hauler'
         default:
             return 'Entity'
     }
@@ -85,19 +129,25 @@ export function moduleDisplayName(itemId: number): string {
         case ITEM_ENGINE_T1:
             return 'Engine'
         case ITEM_GENERATOR_T1:
-            return 'Generator'
+            return 'Power Core'
         case ITEM_GATHERER_T1:
-            return 'Gatherer'
+        case ITEM_GATHERER_T2:
+            return 'Limpet Bay'
         case ITEM_LOADER_T1:
-            return 'Loader'
+            return 'Shuttle Bay'
         case ITEM_CRAFTER_T1:
-            return 'Crafter'
+            return 'Fabricator'
         case ITEM_STORAGE_T1:
-            return 'Storage'
+            return 'Cargo Hold'
         case ITEM_HAULER_T1:
-            return 'Hauler'
+        case ITEM_HAULER_T2:
+            return 'Tractor Beam'
         case ITEM_WARP_T1:
-            return 'Warp'
+            return 'Warp Drive'
+        case ITEM_BATTERY_T1:
+            return 'Battery Bank'
+        case ITEM_LAUNCHER_T1:
+            return 'Drive Coil'
         default:
             return 'Module'
     }
@@ -129,13 +179,12 @@ export function formatModuleLine(slot: number, itemId: number, stats: bigint): s
         case MODULE_GATHERER: {
             const str = decodeStat(stats, 0)
             const tol = decodeStat(stats, 1)
-            const con = decodeStat(stats, 3)
-            const ref = decodeStat(stats, 4)
+            const con = decodeStat(stats, 2)
             const tier = getItem(itemId).tier
             out += `  Yield ${computeGathererYield(str)}  Depth ${computeGathererDepth(
                 tol,
                 tier
-            )}  Speed ${computeGathererSpeed(ref)}  Drain ${computeGathererDrain(con)}`
+            )}  Drain ${computeGathererDrain(con)}`
             break
         }
         case MODULE_LOADER: {
@@ -146,24 +195,24 @@ export function formatModuleLine(slot: number, itemId: number, stats: bigint): s
         }
         case MODULE_CRAFTER: {
             const rea = decodeStat(stats, 0)
-            const com = decodeStat(stats, 1)
-            out += `  Speed ${computeCrafterSpeed(rea)}  Drain ${computeCrafterDrain(com)}`
+            const con = decodeStat(stats, 1)
+            out += `  Speed ${computeCrafterSpeed(rea)}  Drain ${computeCrafterDrain(con)}`
             break
         }
         case MODULE_STORAGE: {
             const str = decodeStat(stats, 0)
-            const fin = decodeStat(stats, 2)
-            const sat = decodeStat(stats, 3)
-            const sum = str + fin + sat
-            const pct = 10 + idiv(sum * 10, 2997)
-            out += `  +${pct}% capacity`
+            const den = decodeStat(stats, 1)
+            const hrd = decodeStat(stats, 2)
+            const com = decodeStat(stats, 3)
+            out += `  Cargo Capacity ${computeCargoBayCapacity(str, den, hrd, com)}`
             break
         }
         case MODULE_HAULER: {
-            const fin = decodeStat(stats, 0)
-            const con = decodeStat(stats, 1)
-            const com = decodeStat(stats, 2)
-            out += `  Capacity ${computeHaulerCapacity(fin)}  Efficiency ${computeHaulerEfficiency(con)}  Drain ${computeHaulerDrain(com)}`
+            const res = decodeStat(stats, 0)
+            const pla = decodeStat(stats, 1)
+            const ref = decodeStat(stats, 2)
+            const tier = getItem(itemId).tier
+            out += `  Capacity ${computeHaulerCapacity(res, tier)}  Efficiency ${computeHaulerEfficiency(pla)}  Drain ${computeHaulerDrain(ref)}`
             break
         }
         case MODULE_WARP: {
@@ -171,6 +220,14 @@ export function formatModuleLine(slot: number, itemId: number, stats: bigint): s
             out += `  Range ${computeWarpRange(stat)}`
             break
         }
+        case MODULE_BATTERY: {
+            const vol = decodeStat(stats, 0)
+            const thm = decodeStat(stats, 1)
+            const pla = decodeStat(stats, 2)
+            const ins = decodeStat(stats, 3)
+            out += `  Energy Capacity ${computeBatteryBankCapacity(vol, thm, pla, ins)}`
+            break
+        }
     }
     return out
 }
@@ -183,10 +240,21 @@ export function buildEntityDescription(
 ): string {
     const hullMass = computeBaseHullmass(hullStats)
     let baseCapacity = 0
-    if (itemId === ITEM_SHIP_T1_PACKED) {
+    if (
+        itemId === ITEM_SHIP_T1_PACKED ||
+        itemId === ITEM_PROSPECTOR_T2_PACKED ||
+        itemId === ITEM_HAULER_SHIP_T2_PACKED
+    ) {
         baseCapacity = computeBaseCapacityShip(hullStats)
     } else if (itemId === ITEM_WAREHOUSE_T1_PACKED) {
         baseCapacity = computeBaseCapacityWarehouse(hullStats)
+    } else if (
+        itemId === ITEM_EXTRACTOR_T1_PACKED ||
+        itemId === ITEM_FACTORY_T1_PACKED ||
+        itemId === ITEM_CONTAINER_T1_PACKED ||
+        itemId === ITEM_CONTAINER_T2_PACKED
+    ) {
+        baseCapacity = computeBaseCapacityContainer(hullStats)
     }
 
     let out = entityDisplayName(itemId)

package/src/nft/index.ts

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

package/src/planner/index.ts

@@ -0,0 +1,242 @@
+import type {GathererStats} from '../types/capabilities'
+import type {ServerContract} from '../contracts'
+import {calc_gather_duration, calc_gather_energy} from '../capabilities/gathering'
+import {calc_rechargetime} from '../travel/travel'
+import {projectRemainingAt, type Projectable} from '../scheduling/projection'
+
+export interface LanePlanEntry {
+    slot: number
+    quantity: number
+}
+
+export type PlanTarget = {quantity: number} | 'max'
+
+export interface GatherPlanEntity extends Projectable {
+    gatherer_lanes: ServerContract.Types.gatherer_lane[]
+    loader_lanes: ServerContract.Types.loader_lane[]
+}
+
+export interface GatherLimpet {
+    slot: number
+    quantity: number
+    durationSeconds: number
+}
+
+export interface GatherCycle {
+    rechargeBefore: boolean
+    rechargeSeconds: number
+    limpets: GatherLimpet[]
+    gatherSeconds: number
+    batchOre: number
+}
+
+export type FillCap = 'reserve' | 'hold' | 'requested'
+
+export interface GatherPlan {
+    cycles: GatherCycle[]
+    cycleCount: number
+    totalOre: number
+    totalSeconds: number
+    cap: FillCap
+    reachingCount: number
+    totalLimpets: number
+    warnings: string[]
+}
+
+export interface BuildGatherPlanOpts {
+    richness: number
+    itemMass: number
+    holdRoom: number
+    reserveRemaining: number
+    now: Date
+}
+
+const MAX_CYCLES = 10_000
+
+const MAX_TRANSFER_QTY = 10000
+
+export function allocateProportional(
+    lanes: {slot: number; weight: number}[],
+    total: number
+): LanePlanEntry[] {
+    if (lanes.length === 0) return []
+    const weightSum = lanes.reduce((s, l) => s + l.weight, 0)
+    if (weightSum === 0) return []
+
+    const entries: LanePlanEntry[] = lanes.map((l) => ({
+        slot: l.slot,
+        quantity: Math.floor((total * l.weight) / weightSum),
+    }))
+
+    let remainder = total - entries.reduce((s, e) => s + e.quantity, 0)
+    for (let i = 0; remainder > 0; i = (i + 1) % entries.length) {
+        entries[i].quantity++
+        remainder--
+    }
+
+    return entries
+}
+
+function laneStats(lane: ServerContract.Types.gatherer_lane): GathererStats {
+    return lane as unknown as GathererStats
+}
+
+export function gatherEnergyCost(
+    lane: ServerContract.Types.gatherer_lane,
+    quantity: number,
+    stratum: number,
+    itemMass: number,
+    richness: number
+): number {
+    if (quantity <= 0) return 0
+    const dur = Number(calc_gather_duration(laneStats(lane), itemMass, quantity, stratum, richness))
+    return Number(calc_gather_energy(laneStats(lane), dur))
+}
+
+export function splitCost(
+    reaching: ServerContract.Types.gatherer_lane[],
+    quantity: number,
+    stratum: number,
+    itemMass: number,
+    richness: number
+): number {
+    if (quantity <= 0) return 0
+    const weights = reaching.map((l) => ({
+        slot: l.slot_index.toNumber(),
+        weight: l.yield.toNumber(),
+    }))
+    const split = allocateProportional(weights, quantity)
+    return split.reduce((sum, e) => {
+        const lane = reaching.find((l) => l.slot_index.toNumber() === e.slot)!
+        return sum + gatherEnergyCost(lane, e.quantity, stratum, itemMass, richness)
+    }, 0)
+}
+
+// Binary search is exact because splitCost is monotonic non-decreasing in Q.
+export function maxQtyForCharge(
+    reaching: ServerContract.Types.gatherer_lane[],
+    hi: number,
+    capacity: number,
+    stratum: number,
+    itemMass: number,
+    richness: number
+): number {
+    if (hi <= 0) return 0
+    if (splitCost(reaching, hi, stratum, itemMass, richness) <= capacity) return hi
+    let lo = 0
+    let high = hi
+    while (lo < high) {
+        const mid = Math.ceil((lo + high) / 2)
+        if (splitCost(reaching, mid, stratum, itemMass, richness) <= capacity) lo = mid
+        else high = mid - 1
+    }
+    return lo
+}
+
+export function buildGatherPlan(
+    entity: GatherPlanEntity,
+    stratum: number,
+    target: PlanTarget,
+    opts: BuildGatherPlanOpts
+): GatherPlan {
+    const {richness, itemMass, holdRoom, reserveRemaining, now} = opts
+    const warnings: string[] = []
+
+    const reaching = entity.gatherer_lanes.filter((l) => l.depth.toNumber() >= stratum)
+    if (reaching.length === 0) throw new Error('no gatherer reaches this stratum')
+    if (!entity.generator) throw new Error('entity has no generator')
+
+    const blocked = entity.gatherer_lanes.length - reaching.length
+    if (blocked > 0) {
+        warnings.push(
+            `${blocked} of ${entity.gatherer_lanes.length} limpets can't reach this depth`
+        )
+    }
+
+    const capacity = entity.generator.capacity.toNumber()
+    const rechargeRate = entity.generator.recharge.toNumber()
+    let energy = Number(projectRemainingAt(entity, now).energy)
+
+    const requested = target === 'max' ? Infinity : target.quantity
+    let fillTarget = requested
+    let cap: FillCap = 'requested'
+    if (holdRoom < fillTarget) {
+        fillTarget = holdRoom
+        cap = 'hold'
+    }
+    if (reserveRemaining < fillTarget) {
+        fillTarget = reserveRemaining
+        cap = 'reserve'
+    }
+    fillTarget = Math.max(0, Math.floor(fillTarget))
+
+    const cycles: GatherCycle[] = []
+    let remaining = fillTarget
+    let guard = 0
+    while (remaining > 0 && guard++ < MAX_CYCLES) {
+        const batch = maxQtyForCharge(reaching, remaining, capacity, stratum, itemMass, richness)
+        if (batch <= 0) {
+            warnings.push('a single gather cannot fit within one full charge')
+            break
+        }
+
+        const costFull = splitCost(reaching, batch, stratum, itemMass, richness)
+        const rechargeBefore = energy < costFull
+        const rechargeSeconds = rechargeBefore
+            ? Number(calc_rechargetime(capacity, energy, rechargeRate))
+            : 0
+        if (rechargeBefore) energy = capacity
+
+        const weights = reaching.map((l) => ({
+            slot: l.slot_index.toNumber(),
+            weight: l.yield.toNumber(),
+        }))
+        const split = allocateProportional(weights, batch).filter((e) => e.quantity > 0)
+        const limpets: GatherLimpet[] = split.map((e) => {
+            const lane = reaching.find((l) => l.slot_index.toNumber() === e.slot)!
+            const dur = Number(
+                calc_gather_duration(laneStats(lane), itemMass, e.quantity, stratum, richness)
+            )
+            return {slot: e.slot, quantity: e.quantity, durationSeconds: dur}
+        })
+        const actualCost = limpets.reduce((sum, l) => {
+            const lane = reaching.find((r) => r.slot_index.toNumber() === l.slot)!
+            return sum + Number(calc_gather_energy(laneStats(lane), l.durationSeconds))
+        }, 0)
+        energy = Math.max(0, energy - actualCost)
+
+        const gatherSeconds = limpets.reduce((m, l) => Math.max(m, l.durationSeconds), 0)
+        cycles.push({rechargeBefore, rechargeSeconds, limpets, gatherSeconds, batchOre: batch})
+        remaining -= batch
+    }
+
+    const totalOre = cycles.reduce((s, c) => s + c.batchOre, 0)
+    const totalSeconds = cycles.reduce((s, c) => s + c.rechargeSeconds + c.gatherSeconds, 0)
+    return {
+        cycles,
+        cycleCount: cycles.length,
+        totalOre,
+        totalSeconds,
+        cap,
+        reachingCount: reaching.length,
+        totalLimpets: entity.gatherer_lanes.length,
+        warnings,
+    }
+}
+
+export function planParallelTransfer(
+    entity: GatherPlanEntity,
+    target: PlanTarget
+): LanePlanEntry[] {
+    const lanes = entity.loader_lanes.filter((l) => l.thrust.toNumber() > 0)
+    if (lanes.length === 0) return []
+
+    const requestedQty = target === 'max' ? MAX_TRANSFER_QTY : target.quantity
+
+    const laneWeights = lanes.map((l) => ({
+        slot: l.slot_index.toNumber(),
+        weight: l.thrust.toNumber(),
+    }))
+
+    return allocateProportional(laneWeights, requestedQty).filter((e) => e.quantity > 0)
+}