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

package/src/influence/civic.test.ts

@@ -0,0 +1,287 @@
+import {describe, expect, test} from 'bun:test'
+import {Name} from '@wharfkit/antelope'
+
+import {
+    MODULE_BUILDER,
+    MODULE_CRAFTER,
+    MODULE_LOADER,
+    MODULE_STORAGE,
+} from '../capabilities/modules'
+import {
+    ITEM_BUILDER_T1,
+    ITEM_CONSTRUCTION_DOCK_T1_PACKED,
+    ITEM_CRAFTER_T1,
+    ITEM_DEPOT_T1_PACKED,
+    ITEM_LOADER_T1,
+    ITEM_STORAGE_T1,
+    ITEM_WORKSHOP_T1_PACKED,
+} from '../data/item-ids'
+import {ENTITY_DEPOT, ENTITY_SHIP, ENTITY_WORKSHOP} from '../data/kind-registry'
+import {decodeStats, encodeStats} from '../derivation/crafting'
+import {CHARTER_REGISTRY, charterNode, type CharterNode} from './charters'
+import {
+    civicBuildingFor,
+    civicHullItem,
+    civicModuleItemFor,
+    civicStatModuleType,
+    emptyCivicModules,
+    fitCivicModules,
+    isCivicEntity,
+    isCivicKind,
+    previewCharterGrants,
+    raiseCivicStat,
+    type CivicStanding,
+} from './civic'
+import {
+    CHARTER_BASELINE_STAT,
+    CHARTER_RUNG_STEP,
+    CIVIC_DEPOT,
+    CIVIC_DOCK,
+    CIVIC_GRANT_RUNG,
+    CIVIC_SPEED_CAP,
+    CIVIC_STAT_CRAFT_SPEED,
+    CIVIC_STAT_STORAGE_CAPACITY,
+    CIVIC_STAT_TRANSFER_SPEED,
+    CIVIC_WORKSHOP,
+} from './constants'
+import {getStatCount} from './quality'
+
+const NODE_WORKSHOP = 10001
+const NODE_WORKSHOP_TUNEUPS = [10100201, 10100202, 10100203, 10100204]
+const NODE_WORKSHOP_TUNEUP = NODE_WORKSHOP_TUNEUPS[0]
+const NODE_DOCK = 30100001
+const NODE_DOCK_TUNEUPS = [30100301, 30100302, 30100303, 30100304]
+const NODE_DEPOT = 40100001
+const NODE_DEPOT_BAYS = [40100101, 40100102, 40100103, 40100104]
+const NODE_DEPOT_LOADERS = [40100401, 40100402, 40100403, 40100404]
+const DEPOT_LOADER_SLOTS = [0, 1]
+const DEPOT_BAY_SLOTS = [2, 3, 4, 5]
+
+function node(nodeId: number): CharterNode {
+    const found = charterNode(nodeId)
+    if (!found) throw new Error(`no charter node ${nodeId}`)
+    return found
+}
+
+function stats(
+    preview: {modules: {installed?: {item_id: unknown; stats: unknown}}[]},
+    slot: number
+) {
+    const installed = preview.modules[slot].installed
+    if (!installed) throw new Error(`slot ${slot} is empty`)
+    const itemId = Number(installed.item_id)
+    return {itemId, stats: decodeStats(BigInt(String(installed.stats)), getStatCount(itemId))}
+}
+
+function complete(standing: CivicStanding, nodeId: number): CivicStanding {
+    const next = {...standing}
+    for (const preview of previewCharterGrants(node(nodeId), standing)) {
+        next[preview.building] = preview.modules
+    }
+    return next
+}
+
+describe('civic building tables', () => {
+    test('each building maps to its restored hull item', () => {
+        expect(civicHullItem(CIVIC_WORKSHOP)).toBe(ITEM_WORKSHOP_T1_PACKED)
+        expect(civicHullItem(CIVIC_DOCK)).toBe(ITEM_CONSTRUCTION_DOCK_T1_PACKED)
+        expect(civicHullItem(CIVIC_DEPOT)).toBe(ITEM_DEPOT_T1_PACKED)
+        expect(civicHullItem(0)).toBe(0)
+    })
+
+    test('each civic stat is carried by one player T1 module type', () => {
+        expect(civicStatModuleType(CIVIC_STAT_CRAFT_SPEED)).toBe(MODULE_CRAFTER)
+        expect(civicStatModuleType(CIVIC_STAT_STORAGE_CAPACITY)).toBe(MODULE_STORAGE)
+        expect(civicStatModuleType(CIVIC_STAT_TRANSFER_SPEED)).toBe(MODULE_LOADER)
+        expect(civicModuleItemFor(MODULE_CRAFTER)).toBe(ITEM_CRAFTER_T1)
+        expect(civicModuleItemFor(MODULE_BUILDER)).toBe(ITEM_BUILDER_T1)
+        expect(civicModuleItemFor(MODULE_LOADER)).toBe(ITEM_LOADER_T1)
+        expect(civicModuleItemFor(MODULE_STORAGE)).toBe(ITEM_STORAGE_T1)
+    })
+
+    test('civic kinds are the four buildings and nothing else', () => {
+        expect(isCivicKind(ENTITY_WORKSHOP)).toBe(true)
+        expect(isCivicKind('depot')).toBe(true)
+        expect(isCivicKind(ENTITY_SHIP)).toBe(false)
+        expect(civicBuildingFor(ENTITY_DEPOT)).toBe(CIVIC_DEPOT)
+    })
+
+    test('civic-ness is the owner, not the kind', () => {
+        const civic = Name.from('eon.shipload')
+        expect(isCivicEntity({owner: 'eon.shipload'}, civic)).toBe(true)
+        expect(isCivicEntity({owner: Name.from('alice')}, civic)).toBe(false)
+    })
+
+    test('every rung in the registry lands on a stat its building defines', () => {
+        for (const entry of CHARTER_REGISTRY) {
+            for (const grant of entry.grants) {
+                if (grant.kind !== CIVIC_GRANT_RUNG) continue
+                expect(civicStatModuleType(grant.stat)).not.toBe(0)
+                const layout = emptyCivicModules(grant.building).map((m) => Number(m.type))
+                expect(layout).toContain(civicStatModuleType(grant.stat))
+            }
+        }
+    })
+})
+
+describe('the fourteen nodes reproduce the chain-fitted buildings', () => {
+    test('the Workshop node spawns five crafters at the baseline stat', () => {
+        const [workshop] = previewCharterGrants(node(NODE_WORKSHOP))
+        expect(workshop.building).toBe(CIVIC_WORKSHOP)
+        expect(workshop.spawned).toBe(true)
+        expect(workshop.itemId).toBe(ITEM_WORKSHOP_T1_PACKED)
+        expect(workshop.modules.length).toBe(5)
+        for (let slot = 0; slot < 5; slot++) {
+            expect(stats(workshop, slot)).toEqual({
+                itemId: ITEM_CRAFTER_T1,
+                stats: [CHARTER_BASELINE_STAT, CHARTER_BASELINE_STAT],
+            })
+        }
+    })
+
+    test('each Workshop tune-up raises every crafter by one rung step, reaching 400', () => {
+        let standing = complete({}, NODE_WORKSHOP)
+        let raised = CHARTER_BASELINE_STAT
+        for (const tuneup of NODE_WORKSHOP_TUNEUPS) {
+            const [workshop] = previewCharterGrants(node(tuneup), standing)
+            expect(workshop.spawned).toBe(false)
+            raised += CHARTER_RUNG_STEP
+            for (let slot = 0; slot < 5; slot++) {
+                expect(stats(workshop, slot).stats).toEqual([raised, raised])
+            }
+            standing = complete(standing, tuneup)
+        }
+        expect(raised).toBe(400)
+    })
+
+    test('the Dock node fits one builder and its four tune-ups reach 400', () => {
+        let standing = complete(complete({}, NODE_WORKSHOP), NODE_DOCK)
+        expect(stats({modules: standing[CIVIC_DOCK]!}, 0)).toEqual({
+            itemId: ITEM_BUILDER_T1,
+            stats: [CHARTER_BASELINE_STAT, CHARTER_BASELINE_STAT],
+        })
+        let raised = CHARTER_BASELINE_STAT
+        for (const tuneup of NODE_DOCK_TUNEUPS) {
+            const [dock] = previewCharterGrants(node(tuneup), standing)
+            raised += CHARTER_RUNG_STEP
+            expect(stats(dock, 0).stats).toEqual([raised, raised])
+            standing = complete(standing, tuneup)
+        }
+        expect(raised).toBe(400)
+    })
+
+    test('the Depot node fits two baseline loaders and leaves the bays empty', () => {
+        const standing = complete(complete({}, NODE_WORKSHOP), NODE_DEPOT)
+        const depot = {modules: standing[CIVIC_DEPOT]!}
+        for (const slot of DEPOT_LOADER_SLOTS) {
+            expect(stats(depot, slot)).toEqual({
+                itemId: ITEM_LOADER_T1,
+                stats: [CHARTER_BASELINE_STAT, CHARTER_BASELINE_STAT],
+            })
+        }
+        for (const slot of DEPOT_BAY_SLOTS) expect(depot.modules[slot].installed).toBeUndefined()
+    })
+
+    test('the four bays fill the storage slots in order at the baseline stat', () => {
+        let standing = complete(complete({}, NODE_WORKSHOP), NODE_DEPOT)
+        for (let i = 0; i < NODE_DEPOT_BAYS.length; i++) {
+            standing = complete(standing, NODE_DEPOT_BAYS[i])
+            const depot = {modules: standing[CIVIC_DEPOT]!}
+            for (let bay = 0; bay < DEPOT_BAY_SLOTS.length; bay++) {
+                const slot = DEPOT_BAY_SLOTS[bay]
+                if (bay <= i) {
+                    expect(stats(depot, slot)).toEqual({
+                        itemId: ITEM_STORAGE_T1,
+                        stats: [
+                            CHARTER_BASELINE_STAT,
+                            CHARTER_BASELINE_STAT,
+                            CHARTER_BASELINE_STAT,
+                            CHARTER_BASELINE_STAT,
+                        ],
+                    })
+                } else {
+                    expect(depot.modules[slot].installed).toBeUndefined()
+                }
+            }
+        }
+    })
+
+    test('the four loader rungs step both loaders by one rung each, reaching 400', () => {
+        let standing = complete(complete({}, NODE_WORKSHOP), NODE_DEPOT)
+        for (let i = 0; i < NODE_DEPOT_LOADERS.length; i++) {
+            standing = complete(standing, NODE_DEPOT_LOADERS[i])
+            const depot = {modules: standing[CIVIC_DEPOT]!}
+            const stat = CHARTER_BASELINE_STAT + CHARTER_RUNG_STEP * (i + 1)
+            for (const slot of DEPOT_LOADER_SLOTS) {
+                expect(stats(depot, slot)).toEqual({itemId: ITEM_LOADER_T1, stats: [stat, stat]})
+            }
+            for (const slot of DEPOT_BAY_SLOTS)
+                expect(depot.modules[slot].installed).toBeUndefined()
+        }
+    })
+})
+
+describe('grant mechanics', () => {
+    test('a module grant joins at a sibling stat', () => {
+        const base = fitCivicModules(emptyCivicModules(CIVIC_DEPOT), 1)
+        const raised = raiseCivicStat(base, {
+            kind: CIVIC_GRANT_RUNG,
+            building: CIVIC_DEPOT,
+            stat: CIVIC_STAT_TRANSFER_SPEED,
+            value: 50,
+        })
+        const withSecondLoader = fitCivicModules(raised, 1)
+        expect(stats({modules: withSecondLoader}, 1).stats).toEqual([50, 50])
+        const withBay = fitCivicModules(withSecondLoader, 1)
+        expect(stats({modules: withBay}, 2).stats).toEqual([0, 0, 0, 0])
+        const withSecondBay = fitCivicModules(
+            raiseCivicStat(withBay, {
+                kind: CIVIC_GRANT_RUNG,
+                building: CIVIC_DEPOT,
+                stat: CIVIC_STAT_STORAGE_CAPACITY,
+                value: 7,
+            }),
+            1
+        )
+        expect(stats({modules: withSecondBay}, 3).stats).toEqual([7, 7, 7, 7])
+    })
+
+    test('a rung caps at the civic speed cap', () => {
+        const fitted = fitCivicModules(emptyCivicModules(CIVIC_WORKSHOP), 5)
+        const raised = raiseCivicStat(fitted, {
+            kind: CIVIC_GRANT_RUNG,
+            building: CIVIC_WORKSHOP,
+            stat: CIVIC_STAT_CRAFT_SPEED,
+            value: 5000,
+        })
+        expect(stats({modules: raised}, 0).stats).toEqual([CIVIC_SPEED_CAP, CIVIC_SPEED_CAP])
+    })
+
+    test('a module grant past the layout is refused', () => {
+        const full = fitCivicModules(emptyCivicModules(CIVIC_DOCK), 2)
+        expect(() => fitCivicModules(full, 1)).toThrow('no open slot')
+    })
+
+    test('a rung with no carrier is refused', () => {
+        expect(() =>
+            raiseCivicStat(emptyCivicModules(CIVIC_DEPOT), {
+                kind: CIVIC_GRANT_RUNG,
+                building: CIVIC_DEPOT,
+                stat: CIVIC_STAT_TRANSFER_SPEED,
+                value: 1,
+            })
+        ).toThrow('no module carrying')
+    })
+
+    test('a grant on a building that is not standing is refused', () => {
+        expect(() => previewCharterGrants(node(NODE_WORKSHOP_TUNEUP))).toThrow('not standing')
+    })
+
+    test('inputs are never mutated', () => {
+        const before = emptyCivicModules(CIVIC_WORKSHOP)
+        const snapshot = before.map((m) => String(m.installed?.stats ?? 'empty'))
+        fitCivicModules(before, 5)
+        expect(before.map((m) => String(m.installed?.stats ?? 'empty'))).toEqual(snapshot)
+        expect(encodeStats([1, 2])).not.toBe(0n)
+    })
+})

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

@@ -0,0 +1,84 @@
+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 INFLUENCE_WEIGHT_FP_MAX = 1_000_000n
+export const INFLUENCE_NEED_FP_MAX = 1_000_000n
+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_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_MASS_MAX = 1_000_000
+export const DECOMP_PROCESSED_MASS_MAX = 1_000_000
+
+export const RESOURCE_ORE = 0
+export const RESOURCE_GAS = 1
+export const RESOURCE_REGOLITH = 2
+export const RESOURCE_BIOMASS = 3
+export const RESOURCE_CRYSTAL = 4
+export const RESOURCE_CATEGORY_COUNT = 5
+
+export const CIVIC_LOADER_STAT = 213
+export const CIVIC_LOADER_TIER = 1
+export const DEFAULT_ORBITAL_Z = 800
+
+export const GRADE_STANDARD = 0
+export const GRADE_PREMIUM = 1
+export const MINTREADY_DEFAULT_CAP = 10
+
+export const BAR_SEED = 102_363
+export const BAR_STEP_UNIT = 20
+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 = 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 = 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}
+
+export function poolKey(category: number, tier: number, grade: number): bigint {
+    return (BigInt(category) << 16n) | (BigInt(tier) << 8n) | BigInt(grade)
+}
+
+export function influenceWeightKey(category: number, tier: number): bigint {
+    return (BigInt(category) << 8n) | BigInt(tier)
+}
+
+export function atomicToPoints(atomic: bigint | number | string): number {
+    return Math.floor(Number(BigInt(atomic.toString())) / INFLUENCE_ATOMIC_PER_POINT)
+}

package/src/influence/decay.ts

@@ -0,0 +1,20 @@
+import {DECAY_MAX_ITERATIONS, DECAY_RETAIN_DEN, DECAY_RETAIN_NUM} from './constants'
+
+export function decayActive(active: bigint, epochsElapsed: number): bigint {
+    const iterations = epochsElapsed > DECAY_MAX_ITERATIONS ? DECAY_MAX_ITERATIONS : epochsElapsed
+    let value = active
+    for (let i = 0; i < iterations && value > 0n; i++) {
+        value = (value * DECAY_RETAIN_NUM) / DECAY_RETAIN_DEN
+    }
+    return value
+}
+
+export interface DecayableStanding {
+    active: bigint
+    lastUpdateEpoch: number
+}
+
+export function normalizeActive(standing: DecayableStanding, epoch: number): bigint {
+    const elapsed = epoch > standing.lastUpdateEpoch ? epoch - standing.lastUpdateEpoch : 0
+    return decayActive(standing.active, elapsed)
+}