@shipload/sdk 1.0.0-next.65 → 1.0.0-next.67

package/src/influence/decomp.ts

@@ -4,40 +4,40 @@ import recipes from '../data/recipes.json'
 import {
     DECOMP_MAX_BUCKETS,
     DECOMP_MAX_DEPTH,
-    DECOMP_PROCESSED_KG_MAX,
-    DECOMP_RAW_KG_MAX,
+    DECOMP_PROCESSED_MASS_MAX,
+    DECOMP_RAW_MASS_MAX,
 } from './constants'
 import {categoryIndex} from './categories'
 
 export interface DecompBucket {
     category: number
     tier: number
-    rawKg: number
+    rawMass: number
 }
 
 export interface DecompEntry {
     itemId: number
-    processedKg: number
+    processedMass: number
     buckets: DecompBucket[]
 }
 
 interface Accumulator {
     buckets: DecompBucket[]
-    processedKg: number
+    processedMass: number
     overflow: boolean
 }
 
-function add(acc: Accumulator, category: number, tier: number, kg: number): void {
+function add(acc: Accumulator, category: number, tier: number, mass: number): void {
     const existing = acc.buckets.find((b) => b.category === category && b.tier === tier)
     if (existing) {
-        existing.rawKg += kg
+        existing.rawMass += mass
         return
     }
     if (acc.buckets.length >= DECOMP_MAX_BUCKETS) {
         acc.overflow = true
         return
     }
-    acc.buckets.push({category, tier, rawKg: kg})
+    acc.buckets.push({category, tier, rawMass: mass})
 }
 
 function walk(itemId: number, multiplier: number, acc: Accumulator, depth: number): void {
@@ -51,14 +51,14 @@ function walk(itemId: number, multiplier: number, acc: Accumulator, depth: numbe
     for (const input of recipe.inputs) {
         const def = tryGetItem(input.itemId)
         const units = multiplier * input.quantity
-        const kg = units * (def ? def.mass : 0)
-        acc.processedKg += kg
+        const mass = units * (def ? def.mass : 0)
+        acc.processedMass += mass
         if (getRecipe(input.itemId)) {
             walk(input.itemId, units, acc, depth + 1)
         } else if (def?.type !== 'resource' || def.category === undefined) {
             acc.overflow = true
         } else {
-            add(acc, categoryIndex(def.category), def.tier, kg)
+            add(acc, categoryIndex(def.category), def.tier, mass)
         }
     }
 }
@@ -66,18 +66,18 @@ function walk(itemId: number, multiplier: number, acc: Accumulator, depth: numbe
 function buildRegistry(): DecompEntry[] {
     const out: DecompEntry[] = []
     for (const recipe of recipes as {outputItemId: number}[]) {
-        const acc: Accumulator = {buckets: [], processedKg: 0, overflow: false}
+        const acc: Accumulator = {buckets: [], processedMass: 0, overflow: false}
         walk(recipe.outputItemId, 1, acc, 0)
         acc.buckets.sort((a, b) => a.category - b.category || a.tier - b.tier)
 
-        const rawTotal = acc.buckets.reduce((sum, b) => sum + b.rawKg, 0)
-        if (rawTotal > DECOMP_RAW_KG_MAX || acc.processedKg > DECOMP_PROCESSED_KG_MAX) {
+        const rawTotal = acc.buckets.reduce((sum, b) => sum + b.rawMass, 0)
+        if (rawTotal > DECOMP_RAW_MASS_MAX || acc.processedMass > DECOMP_PROCESSED_MASS_MAX) {
             acc.overflow = true
         }
 
         out.push({
             itemId: recipe.outputItemId,
-            processedKg: acc.overflow ? 0 : acc.processedKg,
+            processedMass: acc.overflow ? 0 : acc.processedMass,
             buckets: acc.buckets,
         })
     }

package/src/influence/duration.ts

@@ -1,5 +1,10 @@
+import type {NameType} from '@wharfkit/antelope'
+import type {ServerContract} from '../contracts'
+import {getEntityClass} from '../data/kind-registry'
 import {computeLoaderMass, computeLoaderThrust} from '../nft/description'
-import {PRECISION} from '../types'
+import {laneKeyForModule, resolveLaneLoader} from '../scheduling/lanes'
+import {calc_onesided_duration} from '../travel/travel'
+import {MASS_STAT_SCALE, MASS_UNITS_PER_TONNE, PRECISION} from '../types'
 import {CIVIC_LOADER_STAT, CIVIC_LOADER_TIER, DEFAULT_ORBITAL_Z} from './constants'
 
 export interface CivicLoaderStats {
@@ -16,7 +21,7 @@ export function civicLoader(): CivicLoaderStats {
 
 function acceleration(thrust: number, mass: number): number {
     if (mass <= 0) return 0
-    return (thrust / mass) * PRECISION
+    return (thrust / (mass * MASS_STAT_SCALE)) * PRECISION
 }
 
 function flightTime(distance: number, accel: number): number {
@@ -24,13 +29,44 @@ function flightTime(distance: number, accel: number): number {
     return Math.floor(2 * Math.sqrt(distance / accel))
 }
 
-export function contributeDuration(totalMassKg: number, altitudeZ = 0): number {
+export function contributeDuration(totalMass: number, altitudeZ = 0): number {
     const loader = civicLoader()
-    const totalMass = totalMassKg + loader.mass
+    const mass = totalMass + loader.mass
     const z = Math.max(altitudeZ, DEFAULT_ORBITAL_Z)
-    return flightTime(z, acceleration(loader.thrust, totalMass))
+    return flightTime(z, acceleration(loader.thrust, mass))
 }
 
 export function contributeDurationForTonnes(tonnes: number, altitudeZ = 0): number {
-    return contributeDuration(Math.floor(tonnes * 1000), altitudeZ)
+    return contributeDuration(Math.floor(tonnes * MASS_UNITS_PER_TONNE), altitudeZ)
+}
+
+export const DEPOT_LOADER_SLOT = 0
+
+export interface DepotTransferParams {
+    depotModules: ServerContract.Types.module_entry[]
+    depotItemId: number
+    depotKind: NameType
+    depotZ: number
+    shipKind: NameType
+    shipZ: number
+    cargoMass: number
+}
+
+// Mirrors depot.cpp: the depot's slot-0 loader drives the transfer; 0 when no loader is installed.
+export function depotTransferDuration(params: DepotTransferParams): number {
+    const loader = resolveLaneLoader(
+        params.depotModules,
+        params.depotItemId,
+        laneKeyForModule(DEPOT_LOADER_SLOT)
+    )
+    if (!loader.valid) return 0
+    return calc_onesided_duration(
+        loader.thrust,
+        loader.mass,
+        params.shipZ,
+        params.depotZ,
+        getEntityClass(params.shipKind),
+        getEntityClass(params.depotKind),
+        params.cargoMass
+    )
 }

package/src/influence/index.ts

@@ -38,26 +38,79 @@ export {
     civicLoader,
     contributeDuration,
     contributeDurationForTonnes,
+    depotTransferDuration,
+    DEPOT_LOADER_SLOT,
     type CivicLoaderStats,
+    type DepotTransferParams,
 } from './duration'
+export {
+    civicShuttleBays,
+    civicTransfersAtCap,
+    civicTransfersFrom,
+    pendingCivicTransfers,
+    selectCivicShuttleBay,
+    CIVIC_TRANSFER_PER_PLAYER_CAP,
+    type CivicShuttleBay,
+    type PendingCivicTransfer,
+} from './civic-shuttle'
 export {citizenryName, citizenryPatternCount} from './citizenry'
 export {
-    charterEffectTargetEntity,
-    charterEffectTargetPresent,
+    charterBuildingEntity,
     charterEligible,
+    charterEligibleChained,
+    charterGateNodeFor,
     charterIneligible,
     charterNode,
     charterPrereqsMet,
+    charterRungValue,
     charterSingletonMandate,
-    charterSpawnNodeFor,
+    charterModuleCount,
     CHARTER_INELIGIBILITY_MESSAGES,
     CHARTER_REGISTRY,
-    effectiveMandate,
     eligibleCharters,
     type BuiltCharter,
-    type CharterEffect,
+    type CharterGrant,
     type CharterIneligibility,
     type CharterNode,
     type CharterWorld,
-    type ChosenCharter,
+    type WorldBuilding,
 } from './charters'
+export {
+    projectBallot,
+    type BallotInput,
+    type BallotProjection,
+    type BallotVoter,
+    type ProjectedOption,
+    type ProjectedSeat,
+} from './ballot'
+export {
+    charterMetadata,
+    charterName,
+    charterSignature,
+    charterSummary,
+    civicBuildingLabel,
+    civicStatLabel,
+    romanNumeral,
+    type CharterGateSignature,
+    type CharterMeta,
+    type CharterRungSignature,
+    type CharterSignature,
+} from './charter-metadata'
+export {
+    CIVIC_STAT_DEFS,
+    civicBuildingFor,
+    civicBuildingKind,
+    civicHullItem,
+    civicModuleItemFor,
+    civicStatModuleType,
+    emptyCivicModules,
+    findCivicStatDef,
+    fitCivicModules,
+    isCivicEntity,
+    isCivicKind,
+    previewCharterGrants,
+    raiseCivicStat,
+    type CivicBuildingPreview,
+    type CivicStanding,
+    type CivicStatDef,
+} from './civic'

package/src/influence/influence.test.ts

@@ -1,5 +1,6 @@
 import {describe, expect, test} from 'bun:test'
-import {Checksum256} from '@wharfkit/antelope'
+import {Checksum256, UInt8, UInt16, UInt64} from '@wharfkit/antelope'
+import type {ServerContract} from '../contracts'
 import {ITEM_ORE_T1, ITEM_PLATE, ITEM_CRYSTAL_T1} from '../data/item-ids'
 import {categoryIndex} from './categories'
 import {
@@ -19,7 +20,7 @@ import {
     popcount5,
 } from './demand'
 import {findDecomp, DECOMP_REGISTRY} from './decomp'
-import {contributeDuration} from './duration'
+import {depotTransferDuration, contributeDuration} from './duration'
 import {getStatCount, statsSumSq} from './quality'
 import {pricingFromWeights, valueCargoItem, valueContribution} from './valuation'
 import {citizenryName, citizenryPatternCount} from './citizenry'
@@ -135,7 +136,7 @@ describe('decomposition', () => {
         for (let i = 1; i < DECOMP_REGISTRY.length; i++) {
             expect(DECOMP_REGISTRY[i].itemId).toBeGreaterThan(DECOMP_REGISTRY[i - 1].itemId)
         }
-        expect(DECOMP_REGISTRY.length).toBe(57)
+        expect(DECOMP_REGISTRY.length).toBe(56)
     })
 
     test('the retired Workshop has no decomposition entry', () => {
@@ -145,7 +146,7 @@ describe('decomposition', () => {
     test('buckets are sorted and hold only raw resources', () => {
         const entry = findDecomp(ITEM_PLATE)
         if (!entry) throw new Error('Plate has no decomposition entry')
-        expect(entry.processedKg).toBeGreaterThan(0)
+        expect(entry.processedMass).toBeGreaterThan(0)
         for (let i = 1; i < entry.buckets.length; i++) {
             const prev = entry.buckets[i - 1]
             const cur = entry.buckets[i]
@@ -250,18 +251,18 @@ describe('valuation', () => {
 
 describe('contribution duration', () => {
     test('grows with mass and never falls below a single tick', () => {
-        expect(contributeDuration(1_000)).toBeGreaterThan(0)
-        expect(contributeDuration(1_000_000)).toBeGreaterThan(contributeDuration(1_000))
+        expect(contributeDuration(10)).toBeGreaterThan(0)
+        expect(contributeDuration(10_000)).toBeGreaterThan(contributeDuration(10))
     })
 
     test('splitting a haul costs more than one trip', () => {
-        const single = contributeDuration(100_000_000)
-        const hundred = contributeDuration(1_000_000) * 100
+        const single = contributeDuration(1_000_000)
+        const hundred = contributeDuration(10_000) * 100
         expect(hundred).toBeGreaterThan(single)
     })
 
     test('ground level is floored at the base orbital climb', () => {
-        expect(contributeDuration(1_000, 0)).toBe(contributeDuration(1_000, 800))
+        expect(contributeDuration(10, 0)).toBe(contributeDuration(10, 800))
     })
 })
 
@@ -315,3 +316,69 @@ describe('scales', () => {
         expect(NEED_FP_SCALE % INFLUENCE_ATOMIC_PER_POINT).toBe(0)
     })
 })
+
+describe('depot transfer duration', () => {
+    type ModuleEntry = ServerContract.Types.module_entry
+    const DEPOT_ITEM = 10219
+    const LOADER_T1 = 10103
+
+    function makeModuleEntry(itemId: number, stats: bigint): ModuleEntry {
+        return {
+            type: UInt8.from(0),
+            installed: {item_id: UInt16.from(itemId), stats: UInt64.from(stats)},
+        } as unknown as ModuleEntry
+    }
+    function emptySlot(): ModuleEntry {
+        return {type: UInt8.from(0)} as unknown as ModuleEntry
+    }
+
+    // A spawned depot: loader in slot 0, four empty bays after it.
+    const depotWithLoader = (): ModuleEntry[] => [
+        makeModuleEntry(LOADER_T1, packStats(500)),
+        emptySlot(),
+        emptySlot(),
+        emptySlot(),
+        emptySlot(),
+    ]
+    const params = (overrides: Record<string, unknown> = {}) => ({
+        depotModules: depotWithLoader(),
+        depotItemId: DEPOT_ITEM,
+        depotKind: 'depot',
+        depotZ: 0,
+        shipKind: 'ship',
+        shipZ: 0,
+        cargoMass: 100,
+        ...overrides,
+    })
+
+    test('drives off the depot loader, not the ship', () => {
+        expect(depotTransferDuration(params())).toBeGreaterThan(0)
+    })
+
+    test('grows with cargo mass', () => {
+        expect(depotTransferDuration(params({cargoMass: 10_000}))).toBeGreaterThan(
+            depotTransferDuration(params({cargoMass: 100}))
+        )
+    })
+
+    test('empty cargo costs nothing', () => {
+        expect(depotTransferDuration(params({cargoMass: 0}))).toBe(0)
+    })
+
+    test('a depot with no loader installed cannot transfer', () => {
+        expect(depotTransferDuration(params({depotModules: [emptySlot()]}))).toBe(0)
+    })
+
+    test('co-located transfers are floored at the orbital minimum distance', () => {
+        // max(planetary 100, orbital 200) = 200, so anything under 200 reads as 200
+        const touching = depotTransferDuration(params({shipZ: 0, depotZ: 0}))
+        const under = depotTransferDuration(params({shipZ: 150, depotZ: 0}))
+        const over = depotTransferDuration(params({shipZ: 400, depotZ: 0}))
+        expect(under).toBe(touching)
+        expect(over).toBeGreaterThan(touching)
+    })
+
+    test('never reports zero for real cargo', () => {
+        expect(depotTransferDuration(params({cargoMass: 1}))).toBeGreaterThanOrEqual(1)
+    })
+})

package/src/influence/valuation.ts

@@ -1,14 +1,14 @@
 import {getItem} from '../data/catalog'
+import {MASS_UNITS_PER_TONNE} from '../types'
 import {categoryIndex} from './categories'
 import {
     INFLUENCE_ATOMIC_PER_POINT,
-    INFLUENCE_MASS_KG_MAX,
+    INFLUENCE_MASS_MAX,
     INFLUENCE_NEED_FP_MAX,
     INFLUENCE_WEIGHT_FP_MAX,
-    MASS_KG_PER_TONNE,
     NEED_FP_SCALE,
     WEIGHT_FP_SCALE,
-    W_EFF_ATOMIC_PER_KG,
+    W_EFF_ATOMIC_PER_UNIT,
 } from './constants'
 import {findDecomp} from './decomp'
 import type {DemandView} from './demand'
@@ -29,16 +29,16 @@ export interface ValuedItem {
 }
 
 export function weightedQualityAtomic(
-    weightedKgFp: bigint,
+    weightedMassFp: bigint,
     sumSq: number,
     nStats: number,
     d1: number,
     needFp: bigint
 ): bigint {
     if (nStats <= 0 || d1 <= 0) throw new Error('influence: invalid quality divisor')
-    const num = weightedKgFp * BigInt(sumSq) * needFp
+    const num = weightedMassFp * BigInt(sumSq) * needFp
     const den =
-        (BigInt(MASS_KG_PER_TONNE) *
+        (BigInt(MASS_UNITS_PER_TONNE) *
             BigInt(WEIGHT_FP_SCALE) *
             BigInt(nStats) *
             BigInt(d1) *
@@ -48,34 +48,34 @@ export function weightedQualityAtomic(
 }
 
 export function resourceValueAtomic(
-    massKg: bigint,
+    mass: bigint,
     weightFp: bigint,
     sumSq: number,
     nStats: number,
     d1: number,
     needFp: bigint
 ): bigint {
-    if (massKg > INFLUENCE_MASS_KG_MAX) throw new Error('influence: mass out of range')
+    if (mass > INFLUENCE_MASS_MAX) throw new Error('influence: mass out of range')
     if (weightFp > INFLUENCE_WEIGHT_FP_MAX) throw new Error('influence: weight out of range')
     if (needFp > INFLUENCE_NEED_FP_MAX) throw new Error('influence: need out of range')
-    return weightedQualityAtomic(massKg * weightFp, sumSq, nStats, d1, needFp)
+    return weightedQualityAtomic(mass * weightFp, sumSq, nStats, d1, needFp)
 }
 
 export function componentBaseAtomic(
-    weightedRawKgFp: bigint,
+    weightedRawMassFp: bigint,
     sumSq: number,
     nStats: number,
     d1: number
 ): bigint {
-    return weightedQualityAtomic(weightedRawKgFp, sumSq, nStats, d1, BigInt(NEED_FP_SCALE))
+    return weightedQualityAtomic(weightedRawMassFp, sumSq, nStats, d1, BigInt(NEED_FP_SCALE))
 }
 
-export function componentEffortAtomic(processedKgPerUnit: number, quantity: number): bigint {
-    const processed = BigInt(processedKgPerUnit) * BigInt(quantity)
-    if (processed > INFLUENCE_MASS_KG_MAX) {
+export function componentEffortAtomic(processedMassPerUnit: number, quantity: number): bigint {
+    const processed = BigInt(processedMassPerUnit) * BigInt(quantity)
+    if (processed > INFLUENCE_MASS_MAX) {
         throw new Error('influence: processed mass out of range')
     }
-    return processed * W_EFF_ATOMIC_PER_KG
+    return processed * W_EFF_ATOMIC_PER_UNIT
 }
 
 export function valueCargoItem(
@@ -114,14 +114,14 @@ export function valueCargoItem(
 
     let weighted = 0n
     for (const bucket of entry.buckets) {
-        weighted += BigInt(bucket.rawKg) * pricing.weight(bucket.category, bucket.tier)
+        weighted += BigInt(bucket.rawMass) * pricing.weight(bucket.category, bucket.tier)
     }
 
     const perUnit = componentBaseAtomic(weighted, sumSq, nStats, pricing.d1)
     const total = perUnit * BigInt(item.quantity)
     if (total > UINT64_MAX) throw new Error('influence: component value overflow')
 
-    const withEffort = total + componentEffortAtomic(entry.processedKg, item.quantity)
+    const withEffort = total + componentEffortAtomic(entry.processedMass, item.quantity)
     if (withEffort > UINT64_MAX) throw new Error('influence: component value overflow')
     return withEffort
 }