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

package/src/influence/decomp.ts

@@ -0,0 +1,95 @@
+import {tryGetItem} from '../data/catalog'
+import {getRecipe} from '../data/recipes-runtime'
+import recipes from '../data/recipes.json'
+import {
+    DECOMP_MAX_BUCKETS,
+    DECOMP_MAX_DEPTH,
+    DECOMP_PROCESSED_MASS_MAX,
+    DECOMP_RAW_MASS_MAX,
+} from './constants'
+import {categoryIndex} from './categories'
+
+export interface DecompBucket {
+    category: number
+    tier: number
+    rawMass: number
+}
+
+export interface DecompEntry {
+    itemId: number
+    processedMass: number
+    buckets: DecompBucket[]
+}
+
+interface Accumulator {
+    buckets: DecompBucket[]
+    processedMass: number
+    overflow: boolean
+}
+
+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.rawMass += mass
+        return
+    }
+    if (acc.buckets.length >= DECOMP_MAX_BUCKETS) {
+        acc.overflow = true
+        return
+    }
+    acc.buckets.push({category, tier, rawMass: mass})
+}
+
+function walk(itemId: number, multiplier: number, acc: Accumulator, depth: number): void {
+    if (depth > DECOMP_MAX_DEPTH) {
+        acc.overflow = true
+        return
+    }
+    const recipe = getRecipe(itemId)
+    if (!recipe) return
+
+    for (const input of recipe.inputs) {
+        const def = tryGetItem(input.itemId)
+        const units = multiplier * input.quantity
+        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, mass)
+        }
+    }
+}
+
+function buildRegistry(): DecompEntry[] {
+    const out: DecompEntry[] = []
+    for (const recipe of recipes as {outputItemId: number}[]) {
+        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.rawMass, 0)
+        if (rawTotal > DECOMP_RAW_MASS_MAX || acc.processedMass > DECOMP_PROCESSED_MASS_MAX) {
+            acc.overflow = true
+        }
+
+        out.push({
+            itemId: recipe.outputItemId,
+            processedMass: acc.overflow ? 0 : acc.processedMass,
+            buckets: acc.buckets,
+        })
+    }
+    out.sort((a, b) => a.itemId - b.itemId)
+    return out
+}
+
+export const DECOMP_REGISTRY: DecompEntry[] = buildRegistry()
+
+const byItemId = new Map<number, DecompEntry>()
+for (const entry of DECOMP_REGISTRY) byItemId.set(entry.itemId, entry)
+
+export function findDecomp(itemId: number): DecompEntry | undefined {
+    return byItemId.get(itemId)
+}

package/src/influence/demand.ts

@@ -0,0 +1,106 @@
+import {Checksum256, type Checksum256Type, type Checksum512} from '@wharfkit/antelope'
+import {getLocationProfile} from '../derivation/resources'
+import {Coordinates, type CoordinatesType} from '../types'
+import {hash512} from '../utils/hash'
+import {deriveLocationStatic} from '../utils/system'
+import {RESOURCE_CATEGORY_COUNT} from './constants'
+
+export interface DemandTriple {
+    peak: bigint
+    base: bigint
+    floor: bigint
+}
+
+export interface DemandView {
+    abundantMask: number
+    lackingMask: number
+    acute: number
+    needFp: bigint[]
+}
+
+const ALL_CATEGORIES_MASK = 0x1f
+
+export function abundantMaskFor(locationType: number, subtype: number): number {
+    let mask = 0
+    for (const entry of getLocationProfile(locationType, subtype)) {
+        mask |= 1 << entry.category
+    }
+    return mask
+}
+
+export function lackingMaskFrom(abundantMask: number): number {
+    return ~abundantMask & ALL_CATEGORIES_MASK
+}
+
+export function popcount5(mask: number): number {
+    let n = 0
+    for (let i = 0; i < RESOURCE_CATEGORY_COUNT; i++) if (mask & (1 << i)) n++
+    return n
+}
+
+export function pickAcuteCategory(lackingMask: number, roll: number): number {
+    const count = popcount5(lackingMask)
+    if (count === 0) throw new Error('location has no lacking category')
+    let index = roll % count
+    for (let c = 0; c < RESOURCE_CATEGORY_COUNT; c++) {
+        if ((lackingMask & (1 << c)) === 0) continue
+        if (index === 0) return c
+        index--
+    }
+    throw new Error('acute pick fell through')
+}
+
+export function demandRoll(hash: Checksum512): number {
+    const bytes = hash.array
+    return ((bytes[0] << 24) | (bytes[1] << 16) | (bytes[2] << 8) | bytes[3]) >>> 0
+}
+
+export function buildDemand(abundantMask: number, acute: number, triple: DemandTriple): DemandView {
+    const lackingMask = lackingMaskFrom(abundantMask)
+    const needFp: bigint[] = []
+    for (let c = 0; c < RESOURCE_CATEGORY_COUNT; c++) {
+        if (c === acute) needFp.push(triple.peak)
+        else if (lackingMask & (1 << c)) needFp.push(triple.base)
+        else needFp.push(triple.floor)
+    }
+    return {abundantMask, lackingMask, acute, needFp}
+}
+
+export function needForCategory(demand: DemandView, category: number): bigint {
+    if (category < 0 || category >= RESOURCE_CATEGORY_COUNT) {
+        throw new Error('invalid category')
+    }
+    return demand.needFp[category]
+}
+
+// Two distinct seeds: composition from the genesis game seed, acute rotation from the epoch seed.
+export function deriveDemand(args: {
+    gameSeed: Checksum256Type
+    epochSeed: Checksum256Type
+    coordinates: CoordinatesType
+    triple: DemandTriple
+}): DemandView {
+    const coords = Coordinates.from(args.coordinates)
+    const location = deriveLocationStatic(args.gameSeed, coords)
+    const abundant = abundantMaskFor(Number(location.type), Number(location.subtype))
+    if (abundant === 0) throw new Error('location has no composition')
+
+    const hash = hash512(
+        Checksum256.from(args.epochSeed),
+        `demand-${coords.x.toString()}-${coords.y.toString()}`
+    )
+    const acute = pickAcuteCategory(lackingMaskFrom(abundant), demandRoll(hash))
+    return buildDemand(abundant, acute, args.triple)
+}
+
+export function isAbundant(demand: DemandView, category: number): boolean {
+    return (demand.abundantMask & (1 << category)) !== 0
+}
+
+export function isAcute(demand: DemandView, category: number): boolean {
+    return demand.acute === category
+}
+
+export function needMultiplier(demand: DemandView, category: number): number {
+    return Number(needForCategory(demand, category)) / 10_000
+}

package/src/influence/duration.ts

@@ -0,0 +1,101 @@
+import type {NameType} from '@wharfkit/antelope'
+import type {ServerContract} from '../contracts'
+import {getEntityClass} from '../data/kind-registry'
+import {computeLoaderMass, computeLoaderThrust} from '../nft/description'
+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 {
+    thrust: number
+    mass: number
+}
+
+export function civicLoader(): CivicLoaderStats {
+    return {
+        thrust: Math.min(computeLoaderThrust(CIVIC_LOADER_STAT, CIVIC_LOADER_TIER), 65_535),
+        mass: computeLoaderMass(CIVIC_LOADER_STAT),
+    }
+}
+
+function acceleration(thrust: number, mass: number): number {
+    if (mass <= 0) return 0
+    return (thrust / (mass * MASS_STAT_SCALE)) * PRECISION
+}
+
+function flightTime(distance: number, accel: number): number {
+    if (accel <= 0 || distance <= 0) return 0
+    return Math.floor(2 * Math.sqrt(distance / accel))
+}
+
+export function contributeDuration(totalMass: number, altitudeZ = 0): number {
+    const loader = civicLoader()
+    const mass = totalMass + loader.mass
+    const z = Math.max(altitudeZ, DEFAULT_ORBITAL_Z)
+    return flightTime(z, acceleration(loader.thrust, mass))
+}
+
+export function contributeDurationForTonnes(tonnes: number, altitudeZ = 0): number {
+    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
+    )
+}
+
+export interface CivicDropoffParams {
+    buildingModules: ServerContract.Types.module_entry[]
+    buildingItemId: number
+    buildingKind: NameType
+    buildingZ: number
+    shipKind: NameType
+    shipZ: number
+    cargoMass: number
+}
+
+// Mirrors jobs.cpp craftjob: the building's slot-0 loader when one is installed, the civic loader when none is.
+export function civicDropoffDuration(params: CivicDropoffParams): number {
+    const loader = resolveLaneLoader(
+        params.buildingModules,
+        params.buildingItemId,
+        laneKeyForModule(DEPOT_LOADER_SLOT)
+    )
+    if (!loader.valid) return contributeDuration(params.cargoMass, params.shipZ)
+    return calc_onesided_duration(
+        loader.thrust,
+        loader.mass,
+        params.shipZ,
+        params.buildingZ,
+        getEntityClass(params.shipKind),
+        getEntityClass(params.buildingKind),
+        params.cargoMass
+    )
+}

package/src/influence/index.ts

@@ -0,0 +1,118 @@
+export * from './constants'
+export * from './categories'
+export {decayActive, normalizeActive, type DecayableStanding} from './decay'
+export {getStatCount, statsSumSq, qualityFactor} from './quality'
+export {
+    DECOMP_REGISTRY,
+    findDecomp,
+    type DecompBucket,
+    type DecompEntry,
+} from './decomp'
+export {
+    abundantMaskFor,
+    buildDemand,
+    demandRoll,
+    deriveDemand,
+    isAbundant,
+    isAcute,
+    lackingMaskFrom,
+    needForCategory,
+    needMultiplier,
+    pickAcuteCategory,
+    popcount5,
+    type DemandTriple,
+    type DemandView,
+} from './demand'
+export {
+    componentBaseAtomic,
+    componentEffortAtomic,
+    pricingFromWeights,
+    resourceValueAtomic,
+    valueCargoItem,
+    valueContribution,
+    weightedQualityAtomic,
+    type InfluencePricing,
+    type ValuedItem,
+} from './valuation'
+export {
+    civicDropoffDuration,
+    civicLoader,
+    contributeDuration,
+    contributeDurationForTonnes,
+    depotTransferDuration,
+    DEPOT_LOADER_SLOT,
+    type CivicDropoffParams,
+    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 {
+    charterBuildingEntity,
+    charterEligible,
+    charterEligibleChained,
+    charterGateNodeFor,
+    charterIneligible,
+    charterNode,
+    charterPrereqsMet,
+    charterRungValue,
+    charterSingletonMandate,
+    charterModuleCount,
+    CHARTER_INELIGIBILITY_MESSAGES,
+    CHARTER_REGISTRY,
+    eligibleCharters,
+    type BuiltCharter,
+    type CharterGrant,
+    type CharterIneligibility,
+    type CharterNode,
+    type CharterWorld,
+    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'