@shipload/sdk 1.0.0-next.64 → 1.0.0-next.66

package/src/influence/civic.ts

@@ -0,0 +1,269 @@
+import {Name, type NameType, UInt16, UInt64, UInt8} from '@wharfkit/antelope'
+import {
+    getModuleCapabilityType,
+    MODULE_BUILDER,
+    MODULE_CRAFTER,
+    MODULE_LOADER,
+    MODULE_STORAGE,
+    moduleSlotTypeToCode,
+} from '../capabilities/modules'
+import {ServerContract} from '../contracts'
+import {
+    ITEM_BUILDER_T1,
+    ITEM_CONSTRUCTION_DOCK_T1_PACKED,
+    ITEM_CRAFTER_T1,
+    ITEM_DEPOT_T1_PACKED,
+    ITEM_LOADER_T1,
+    ITEM_NEXUS_T1_PACKED,
+    ITEM_STORAGE_T1,
+    ITEM_WORKSHOP_T1_PACKED,
+} from '../data/item-ids'
+import {
+    ENTITY_CONSTRUCTION_DOCK,
+    ENTITY_DEPOT,
+    ENTITY_NEXUS,
+    ENTITY_WORKSHOP,
+} from '../data/kind-registry'
+import {getEntityLayout} from '../data/recipes-runtime'
+import {decodeStat, encodeStats} from '../derivation/crafting'
+import type {CharterGrant, CharterNode} from './charters'
+import {
+    CIVIC_DEPOT,
+    CIVIC_DOCK,
+    CIVIC_GRANT_LEVEL_GATE,
+    CIVIC_GRANT_MODULE,
+    CIVIC_GRANT_RUNG,
+    CIVIC_NEXUS,
+    CIVIC_SPEED_CAP,
+    CIVIC_STAT_BUILD_SPEED,
+    CIVIC_STAT_CRAFT_SPEED,
+    CIVIC_STAT_STORAGE_CAPACITY,
+    CIVIC_STAT_TRANSFER_SPEED,
+    CIVIC_WORKSHOP,
+} from './constants'
+import {getStatCount} from './quality'
+
+type ModuleEntry = ServerContract.Types.module_entry
+
+export interface CivicStatDef {
+    building: number
+    stat: number
+    base: number
+    cap: number
+}
+
+export const CIVIC_STAT_DEFS: readonly CivicStatDef[] = [
+    {building: CIVIC_WORKSHOP, stat: CIVIC_STAT_CRAFT_SPEED, base: 0, cap: CIVIC_SPEED_CAP},
+    {building: CIVIC_DOCK, stat: CIVIC_STAT_BUILD_SPEED, base: 0, cap: CIVIC_SPEED_CAP},
+    {building: CIVIC_DEPOT, stat: CIVIC_STAT_TRANSFER_SPEED, base: 0, cap: CIVIC_SPEED_CAP},
+    {building: CIVIC_DEPOT, stat: CIVIC_STAT_STORAGE_CAPACITY, base: 0, cap: CIVIC_SPEED_CAP},
+]
+
+export function findCivicStatDef(building: number, stat: number): CivicStatDef | undefined {
+    return CIVIC_STAT_DEFS.find((def) => def.building === building && def.stat === stat)
+}
+
+export function civicHullItem(building: number): number {
+    switch (building) {
+        case CIVIC_WORKSHOP:
+            return ITEM_WORKSHOP_T1_PACKED
+        case CIVIC_NEXUS:
+            return ITEM_NEXUS_T1_PACKED
+        case CIVIC_DOCK:
+            return ITEM_CONSTRUCTION_DOCK_T1_PACKED
+        case CIVIC_DEPOT:
+            return ITEM_DEPOT_T1_PACKED
+        default:
+            return 0
+    }
+}
+
+export function civicModuleItemFor(moduleType: number): number {
+    switch (moduleType) {
+        case MODULE_CRAFTER:
+            return ITEM_CRAFTER_T1
+        case MODULE_BUILDER:
+            return ITEM_BUILDER_T1
+        case MODULE_LOADER:
+            return ITEM_LOADER_T1
+        case MODULE_STORAGE:
+            return ITEM_STORAGE_T1
+        default:
+            return 0
+    }
+}
+
+export function civicStatModuleType(stat: number): number {
+    switch (stat) {
+        case CIVIC_STAT_CRAFT_SPEED:
+            return MODULE_CRAFTER
+        case CIVIC_STAT_BUILD_SPEED:
+            return MODULE_BUILDER
+        case CIVIC_STAT_TRANSFER_SPEED:
+            return MODULE_LOADER
+        case CIVIC_STAT_STORAGE_CAPACITY:
+            return MODULE_STORAGE
+        default:
+            return 0
+    }
+}
+
+export function civicBuildingKind(building: number): Name | undefined {
+    switch (building) {
+        case CIVIC_WORKSHOP:
+            return ENTITY_WORKSHOP
+        case CIVIC_NEXUS:
+            return ENTITY_NEXUS
+        case CIVIC_DOCK:
+            return ENTITY_CONSTRUCTION_DOCK
+        case CIVIC_DEPOT:
+            return ENTITY_DEPOT
+        default:
+            return undefined
+    }
+}
+
+export function civicBuildingFor(kind: NameType): number | undefined {
+    const name = Name.from(kind)
+    if (name.equals(ENTITY_WORKSHOP)) return CIVIC_WORKSHOP
+    if (name.equals(ENTITY_NEXUS)) return CIVIC_NEXUS
+    if (name.equals(ENTITY_CONSTRUCTION_DOCK)) return CIVIC_DOCK
+    if (name.equals(ENTITY_DEPOT)) return CIVIC_DEPOT
+    return undefined
+}
+
+export function isCivicKind(kind: NameType): boolean {
+    return civicBuildingFor(kind) !== undefined
+}
+
+export function isCivicEntity(entity: {owner: NameType}, civicOwner: NameType): boolean {
+    return Name.from(entity.owner).equals(Name.from(civicOwner))
+}
+
+function moduleItemId(module: ServerContract.Types.packed_module): number {
+    return Number(module.item_id.value ?? module.item_id)
+}
+
+function moduleStats(module: ServerContract.Types.packed_module): bigint {
+    return BigInt(module.stats.toString())
+}
+
+function packedModule(itemId: number, stats: bigint): ServerContract.Types.packed_module {
+    return ServerContract.Types.packed_module.from({
+        item_id: UInt16.from(itemId),
+        stats: UInt64.from(stats.toString()),
+    })
+}
+
+function cloneEntry(
+    entry: ModuleEntry,
+    installed?: ServerContract.Types.packed_module
+): ModuleEntry {
+    return ServerContract.Types.module_entry.from({
+        type: UInt8.from(Number(entry.type.value ?? entry.type)),
+        installed:
+            installed ??
+            (entry.installed
+                ? packedModule(moduleItemId(entry.installed), moduleStats(entry.installed))
+                : undefined),
+    })
+}
+
+export function emptyCivicModules(building: number): ModuleEntry[] {
+    const layout = getEntityLayout(civicHullItem(building))?.slots ?? []
+    return layout.map((slot) =>
+        ServerContract.Types.module_entry.from({type: UInt8.from(moduleSlotTypeToCode(slot.type))})
+    )
+}
+
+export function fitCivicModules(modules: ModuleEntry[], count: number): ModuleEntry[] {
+    const next = modules.map((entry) => cloneEntry(entry))
+    let remaining = count
+    for (let i = 0; i < next.length && remaining > 0; i++) {
+        if (next[i].installed) continue
+        const type = Number(next[i].type.value ?? next[i].type)
+        const item = civicModuleItemFor(type)
+        if (item === 0) throw new Error('charter grant found no open slot of its module type')
+        let stats = encodeStats(new Array(getStatCount(item)).fill(0))
+        for (const sibling of next) {
+            if (
+                sibling.installed &&
+                getModuleCapabilityType(moduleItemId(sibling.installed)) === type
+            ) {
+                stats = moduleStats(sibling.installed)
+                break
+            }
+        }
+        next[i] = cloneEntry(next[i], packedModule(item, stats))
+        remaining--
+    }
+    if (remaining > 0) throw new Error('charter grant found no open slot of its module type')
+    return next
+}
+
+export function raiseCivicStat(modules: ModuleEntry[], grant: CharterGrant): ModuleEntry[] {
+    const def = findCivicStatDef(grant.building, grant.stat)
+    if (!def) throw new Error(`no civic stat ${grant.stat} on building ${grant.building}`)
+    const type = civicStatModuleType(grant.stat)
+    let raised = 0
+    const next = modules.map((entry) => {
+        if (!entry.installed || getModuleCapabilityType(moduleItemId(entry.installed)) !== type) {
+            return cloneEntry(entry)
+        }
+        const item = moduleItemId(entry.installed)
+        const stats = moduleStats(entry.installed)
+        const values: number[] = []
+        for (let c = 0; c < getStatCount(item); c++) {
+            values.push(Math.min(decodeStat(stats, c) + grant.value, def.cap))
+        }
+        raised++
+        return cloneEntry(entry, packedModule(item, encodeStats(values)))
+    })
+    if (raised === 0) throw new Error('charter rung found no module carrying its stat')
+    return next
+}
+
+export interface CivicBuildingPreview {
+    building: number
+    itemId: number
+    spawned: boolean
+    modules: ModuleEntry[]
+}
+
+export type CivicStanding = Partial<Record<number, ModuleEntry[]>>
+
+export function previewCharterGrants(
+    node: CharterNode,
+    standing: CivicStanding = {}
+): CivicBuildingPreview[] {
+    const previews = new Map<number, CivicBuildingPreview>()
+    const target = (building: number, spawn: boolean): CivicBuildingPreview => {
+        let preview = previews.get(building)
+        if (preview) return preview
+        const current = standing[building]
+        if (!current && !spawn)
+            throw new Error('charter grant targets a building that is not standing')
+        preview = {
+            building,
+            itemId: civicHullItem(building),
+            spawned: !current,
+            modules: current
+                ? current.map((entry) => cloneEntry(entry))
+                : emptyCivicModules(building),
+        }
+        previews.set(building, preview)
+        return preview
+    }
+    for (const grant of node.grants) {
+        if (grant.kind === CIVIC_GRANT_LEVEL_GATE) {
+            target(grant.building, true)
+        } else if (grant.kind === CIVIC_GRANT_MODULE) {
+            const preview = target(grant.building, false)
+            preview.modules = fitCivicModules(preview.modules, grant.value)
+        } else if (grant.kind === CIVIC_GRANT_RUNG) {
+            const preview = target(grant.building, false)
+            preview.modules = raiseCivicStat(preview.modules, grant)
+        }
+    }
+    return [...previews.values()]
+}

package/src/influence/constants.ts

@@ -1,22 +1,23 @@
+import {MASS_UNITS_PER_TONNE} from '../types'
+
 export const INFLUENCE_ATOMIC_PER_POINT = 10_000
 export const NEED_FP_SCALE = 10_000
 export const WEIGHT_FP_SCALE = 10_000
-export const MASS_KG_PER_TONNE = 1_000
 
 export const INFLUENCE_WEIGHT_FP_MAX = 1_000_000n
 export const INFLUENCE_NEED_FP_MAX = 1_000_000n
-export const INFLUENCE_MASS_KG_MAX = 1n << 48n
+export const INFLUENCE_MASS_MAX = 1n << 48n
 
 export const DECAY_RETAIN_NUM = 19n
 export const DECAY_RETAIN_DEN = 20n
 export const DECAY_MAX_ITERATIONS = 1_024
 
-export const W_EFF_ATOMIC_PER_KG = BigInt(INFLUENCE_ATOMIC_PER_POINT / MASS_KG_PER_TONNE)
+export const W_EFF_ATOMIC_PER_UNIT = BigInt(INFLUENCE_ATOMIC_PER_POINT / MASS_UNITS_PER_TONNE)
 
 export const DECOMP_MAX_BUCKETS = 12
 export const DECOMP_MAX_DEPTH = 8
-export const DECOMP_RAW_KG_MAX = 100_000_000
-export const DECOMP_PROCESSED_KG_MAX = 100_000_000
+export const DECOMP_RAW_MASS_MAX = 1_000_000
+export const DECOMP_PROCESSED_MASS_MAX = 1_000_000
 
 export const RESOURCE_ORE = 0
 export const RESOURCE_GAS = 1
@@ -39,13 +40,33 @@ export const BAR_STEP_UP = BAR_STEP_UNIT * 9
 export const BAR_STEP_DOWN = BAR_STEP_UNIT
 
 export const CHARTER_NONE = 0
-export const CHARTER_WORKSHOP = 1
-export const CHARTER_EFFECT_SPAWN_ENTITY = 1
-export const CHARTER_EFFECT_REFIT_MODULES = 2
+export const CHARTER_WORKSHOP = 10001
+export const CIVIC_GRANT_NONE = 0
+export const CIVIC_GRANT_MODULE = 1
+export const CIVIC_GRANT_RUNG = 2
+export const CIVIC_GRANT_LEVEL_GATE = 3
+export const CIVIC_GRANT_ADVANCEMENT = 4
+
+export const CIVIC_WORLD = 0
+export const CIVIC_WORKSHOP = 1
+export const CIVIC_NEXUS = 2
+export const CIVIC_DOCK = 3
+export const CIVIC_DEPOT = 4
+
+export const CIVIC_STAT_NONE = 0
+export const CIVIC_STAT_CRAFT_SPEED = 1
+export const CIVIC_STAT_BUILD_SPEED = 2
+export const CIVIC_STAT_TRANSFER_SPEED = 3
+export const CIVIC_STAT_STORAGE_CAPACITY = 4
 export const VOTE_READY_DEFAULT_MAX = 20
+export const BALLOT_CHARTER = 1
+export const BALLOT_MAX_PICKS = 8
 export const CHARTER_WORKSHOP_COST = 2_000_000_000n
-export const CHARTER_BASELINE_STAT = 213
+export const CHARTER_BASELINE_STAT = 200
+export const CHARTER_RUNG_STEP = 50
+export const CIVIC_SPEED_CAP = 999
 export const CHARTER_MAX_PREREQS = 4
+export const CHARTER_MAX_GRANTS = 4
 
 export const INFLUENCE_D1_SEED = 45_369
 export const DEMAND_TRIPLE_SEED = {peak: 20_000n, base: 10_000n, floor: 1_000n}

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,69 @@ export {
     civicLoader,
     contributeDuration,
     contributeDurationForTonnes,
+    depotTransferDuration,
+    DEPOT_LOADER_SLOT,
     type CivicLoaderStats,
+    type DepotTransferParams,
 } from './duration'
 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'