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

package/src/influence/charters.ts

@@ -1,26 +1,34 @@
 import chartersJson from '../data/charters.json'
-import {CHARTER_EFFECT_REFIT_MODULES, CHARTER_EFFECT_SPAWN_ENTITY, CHARTER_NONE} from './constants'
-
-export interface CharterEffect {
+import {
+    CHARTER_NONE,
+    CIVIC_GRANT_LEVEL_GATE,
+    CIVIC_GRANT_MODULE,
+    CIVIC_GRANT_RUNG,
+} from './constants'
+
+export interface CharterGrant {
     kind: number
-    itemId: number
-    targetItemId: number
-    slotMask: number
+    building: number
     stat: number
+    value: number
 }
 
 export interface CharterNode {
     nodeId: number
     cost: bigint
     prereqs: number[]
-    effect: CharterEffect
+    grants: CharterGrant[]
+    exclusionGroup: number
+    repeatCap: number
 }
 
 export const CHARTER_REGISTRY: CharterNode[] = chartersJson.nodes.map((node) => ({
     nodeId: node.nodeId,
     cost: BigInt(node.cost),
     prereqs: [...node.prereqs],
-    effect: {...node.effect},
+    grants: node.grants.map((grant) => ({...grant})),
+    exclusionGroup: node.exclusionGroup,
+    repeatCap: node.repeatCap,
 }))
 
 export function charterNode(nodeId: number): CharterNode | undefined {
@@ -28,58 +36,77 @@ export function charterNode(nodeId: number): CharterNode | undefined {
     return CHARTER_REGISTRY.find((n) => n.nodeId === nodeId)
 }
 
-export type CharterIneligibility = 'already-taken' | 'prereq-missing' | 'refit-target-missing'
+export type CharterIneligibility = 'already-taken' | 'prereq-missing'
 
 export const CHARTER_INELIGIBILITY_MESSAGES: Record<CharterIneligibility, string> = {
     'already-taken': 'charter is already completed at this world',
     'prereq-missing': 'charter prerequisites are not completed',
-    'refit-target-missing': 'charter refit target not found at this world',
 }
 
 export interface BuiltCharter {
     nodeId: number
-    entityId: bigint
+    repeats: number
 }
 
 export interface CharterWorld {
     built: BuiltCharter[]
-    entityExists?: (entityId: bigint) => boolean
 }
 
-export interface ChosenCharter {
-    chosen: number
-    chosenEpoch: number
+export interface WorldBuilding {
+    entityId: bigint
+    building: number
 }
 
 function builtCharter(world: CharterWorld, nodeId: number): BuiltCharter | undefined {
     return world.built.find((row) => row.nodeId === nodeId)
 }
 
-export function charterSpawnNodeFor(targetItemId: number): CharterNode | undefined {
-    return CHARTER_REGISTRY.find(
-        (node) =>
-            node.effect.kind === CHARTER_EFFECT_SPAWN_ENTITY && node.effect.itemId === targetItemId
+export function charterGateNodeFor(building: number, level: number = 1): CharterNode | undefined {
+    return CHARTER_REGISTRY.find((node) =>
+        node.grants.some(
+            (grant) =>
+                grant.kind === CIVIC_GRANT_LEVEL_GATE &&
+                grant.building === building &&
+                grant.value === level
+        )
     )
 }
 
-export function charterPrereqsMet(world: CharterWorld, node: CharterNode): boolean {
-    return node.prereqs.every(
-        (prereq) => prereq === CHARTER_NONE || builtCharter(world, prereq) !== undefined
-    )
+export function charterBuildingEntity(buildings: WorldBuilding[], building: number): bigint {
+    const record = buildings.find((row) => row.building === building)
+    return record ? record.entityId : 0n
+}
+
+export function charterRungValue(world: CharterWorld, building: number, stat: number): number {
+    let total = 0
+    for (const node of CHARTER_REGISTRY) {
+        if (builtCharter(world, node.nodeId) === undefined) continue
+        for (const grant of node.grants) {
+            if (grant.kind !== CIVIC_GRANT_RUNG) continue
+            if (grant.building !== building || grant.stat !== stat) continue
+            total += grant.value
+        }
+    }
+    return total
 }
 
-export function charterEffectTargetEntity(world: CharterWorld, node: CharterNode): bigint {
-    const spawn = charterSpawnNodeFor(node.effect.targetItemId)
-    if (!spawn) return 0n
-    const record = builtCharter(world, spawn.nodeId)
-    if (!record) return 0n
-    if (world.entityExists && !world.entityExists(record.entityId)) return 0n
-    return record.entityId
+export function charterModuleCount(world: CharterWorld, building: number): number {
+    let total = 0
+    for (const node of CHARTER_REGISTRY) {
+        if (builtCharter(world, node.nodeId) === undefined) continue
+        for (const grant of node.grants) {
+            if (grant.kind !== CIVIC_GRANT_MODULE) continue
+            if (grant.building !== building) continue
+            total += grant.value
+        }
+    }
+    return total
 }
 
-export function charterEffectTargetPresent(world: CharterWorld, node: CharterNode): boolean {
-    if (node.effect.kind !== CHARTER_EFFECT_REFIT_MODULES) return true
-    return charterEffectTargetEntity(world, node) !== 0n
+export function charterPrereqsMet(world: CharterWorld, node: CharterNode): boolean {
+    return node.prereqs.every(
+        (prereq) => prereq === CHARTER_NONE || builtCharter(world, prereq) !== undefined
+    )
 }
 
 export function charterIneligible(
@@ -88,7 +115,6 @@ export function charterIneligible(
 ): CharterIneligibility | undefined {
     if (builtCharter(world, node.nodeId) !== undefined) return 'already-taken'
     if (!charterPrereqsMet(world, node)) return 'prereq-missing'
-    if (!charterEffectTargetPresent(world, node)) return 'refit-target-missing'
     return undefined
 }
 
@@ -110,11 +136,15 @@ export function charterSingletonMandate(world: CharterWorld): number {
     return only
 }
 
-export function effectiveMandate(
-    stored: ChosenCharter,
+export function charterEligibleChained(
     world: CharterWorld,
-    epoch: number
-): number {
-    if (stored.chosen !== CHARTER_NONE && stored.chosenEpoch === epoch) return stored.chosen
-    return charterSingletonMandate(world)
+    node: CharterNode,
+    seated: number[]
+): boolean {
+    if (builtCharter(world, node.nodeId) !== undefined || seated.includes(node.nodeId)) return false
+    for (const prereq of node.prereqs) {
+        if (prereq === CHARTER_NONE) continue
+        if (builtCharter(world, prereq) === undefined && !seated.includes(prereq)) return false
+    }
+    return true
 }

package/src/influence/civic-shuttle.test.ts

@@ -0,0 +1,159 @@
+import {UInt8, UInt16, UInt32, UInt64} from '@wharfkit/antelope'
+import {expect, test} from 'bun:test'
+import type {ServerContract} from '../contracts'
+import {encodeStats} from '../derivation/crafting'
+import {ITEM_DEPOT_T1_PACKED, ITEM_LOADER_T1, ITEM_STORAGE_T1} from '../data/item-ids'
+import {JOB_QUEUE_CAP} from '../scheduling/jobs'
+import {HoldKind, TaskType} from '../types'
+import {
+    civicShuttleBays,
+    civicTransfersAtCap,
+    civicTransfersFrom,
+    pendingCivicTransfers,
+    selectCivicShuttleBay,
+    CIVIC_TRANSFER_PER_PLAYER_CAP,
+} from './civic-shuttle'
+
+type Lane = ServerContract.Types.lane
+type ModuleEntry = ServerContract.Types.module_entry
+type Task = ServerContract.Types.task
+
+const T0 = new Date('2026-01-01T00:00:00.000Z')
+const loaderStats = encodeStats([300, 500])
+const storageStats = encodeStats([300, 300])
+
+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
+}
+
+// The live Depot layout: two loader bays then four storage.
+function depotModules(): ModuleEntry[] {
+    return [
+        makeModuleEntry(ITEM_LOADER_T1, loaderStats),
+        makeModuleEntry(ITEM_LOADER_T1, loaderStats),
+        makeModuleEntry(ITEM_STORAGE_T1, storageStats),
+        makeModuleEntry(ITEM_STORAGE_T1, storageStats),
+        makeModuleEntry(ITEM_STORAGE_T1, storageStats),
+        makeModuleEntry(ITEM_STORAGE_T1, storageStats),
+    ]
+}
+
+function shuttleTask(senderId: number, receiverId: number, group?: number): Task {
+    return {
+        type: UInt8.from(TaskType.SHUTTLE),
+        duration: UInt32.from(60),
+        cancelable: UInt8.from(2),
+        cargo: [],
+        couplings: [
+            {
+                counterpart: {entity_id: UInt64.from(senderId), entity_type: UInt8.from(1)},
+                hold: UInt64.from(1),
+                kind: UInt8.from(HoldKind.PULL),
+            },
+            {
+                counterpart: {entity_id: UInt64.from(receiverId), entity_type: UInt8.from(1)},
+                hold: UInt64.from(1),
+                kind: UInt8.from(HoldKind.PUSH),
+            },
+        ],
+        entitygroup: group === undefined ? undefined : UInt64.from(group),
+    } as unknown as Task
+}
+
+function makeLane(laneKey: number, tasks: Task[]): Lane {
+    return {
+        lane_key: UInt8.from(laneKey),
+        schedule: {started: {toDate: () => T0}, tasks},
+    } as unknown as Lane
+}
+
+test('civicShuttleBays lists both Depot bays with their queue depth', () => {
+    const lanes = [makeLane(1, [shuttleTask(20, 21)])]
+    const bays = civicShuttleBays(depotModules(), ITEM_DEPOT_T1_PACKED, lanes)
+    expect(bays.map((b) => b.laneKey)).toEqual([1, 2])
+    expect(bays.map((b) => b.slotIndex)).toEqual([0, 1])
+    expect(bays[0].queued).toBe(1)
+    expect(bays[1].queued).toBe(0)
+    expect(bays.every((b) => !b.full)).toBe(true)
+    expect(bays.every((b) => b.thrust > 0 && b.mass > 0)).toBe(true)
+})
+
+test('a bay is full at the job queue cap', () => {
+    const filled = Array.from({length: JOB_QUEUE_CAP}, () => shuttleTask(20, 21))
+    const bays = civicShuttleBays(depotModules(), ITEM_DEPOT_T1_PACKED, [makeLane(1, filled)])
+    expect(bays[0].full).toBe(true)
+    expect(bays[1].full).toBe(false)
+})
+
+test('selectCivicShuttleBay takes the first free bay, then the lowest occupied one', () => {
+    const modules = depotModules()
+    expect(selectCivicShuttleBay(modules, ITEM_DEPOT_T1_PACKED, [])?.laneKey).toBe(1)
+
+    const firstBusy = [makeLane(1, [shuttleTask(20, 21)])]
+    expect(selectCivicShuttleBay(modules, ITEM_DEPOT_T1_PACKED, firstBusy)?.laneKey).toBe(2)
+
+    const bothBusy = [makeLane(1, [shuttleTask(20, 21)]), makeLane(2, [shuttleTask(22, 23)])]
+    expect(selectCivicShuttleBay(modules, ITEM_DEPOT_T1_PACKED, bothBusy)?.laneKey).toBe(1)
+})
+
+test('selectCivicShuttleBay returns nothing when the building has no loaders', () => {
+    const modules = [makeModuleEntry(ITEM_STORAGE_T1, storageStats)]
+    expect(selectCivicShuttleBay(modules, ITEM_DEPOT_T1_PACKED, [])).toBeUndefined()
+})
+
+test('pendingCivicTransfers reports the bay, both counterparties, and the tail', () => {
+    const lanes = [
+        makeLane(1, [shuttleTask(20, 21), shuttleTask(22, 23)]),
+        makeLane(2, [shuttleTask(24, 25)]),
+    ]
+    const transfers = pendingCivicTransfers({lanes} as never)
+    expect(transfers.length).toBe(3)
+
+    const first = transfers.find((t) => String(t.senderId) === '20')!
+    expect(first.laneKey).toBe(1)
+    expect(String(first.receiverId)).toBe('21')
+    expect(first.isTail).toBe(false)
+    expect(first.callable).toBe(false)
+    expect(first.startsAt).toEqual(T0)
+    expect(first.completesAt).toEqual(new Date(T0.getTime() + 60_000))
+
+    const second = transfers.find((t) => String(t.senderId) === '22')!
+    expect(second.isTail).toBe(true)
+    expect(second.callable).toBe(true)
+
+    const onBayTwo = transfers.find((t) => String(t.senderId) === '24')!
+    expect(onBayTwo.laneKey).toBe(2)
+    expect(onBayTwo.callable).toBe(true)
+})
+
+test('a grouped tail transfer is not callable', () => {
+    const lanes = [makeLane(1, [shuttleTask(20, 21, 7)])]
+    const [transfer] = pendingCivicTransfers({lanes} as never)
+    expect(transfer.isTail).toBe(true)
+    expect(transfer.callable).toBe(false)
+})
+
+test('civicTransfersFrom counts only the ships a player sends from', () => {
+    const lanes = [
+        makeLane(1, [shuttleTask(20, 21), shuttleTask(30, 31)]),
+        makeLane(2, [shuttleTask(22, 23)]),
+    ]
+    const entity = {lanes} as never
+    expect(civicTransfersFrom(entity, [20, 22]).length).toBe(2)
+    expect(civicTransfersFrom(entity, [30]).length).toBe(1)
+    expect(civicTransfersFrom(entity, [99]).length).toBe(0)
+})
+
+test('civicTransfersAtCap trips at the per-player cap', () => {
+    const mine = Array.from({length: CIVIC_TRANSFER_PER_PLAYER_CAP}, (_, i) =>
+        shuttleTask(20 + i, 50)
+    )
+    const senderIds = mine.map((_, i) => 20 + i)
+    const under = {lanes: [makeLane(1, mine.slice(0, -1))]} as never
+    const at = {lanes: [makeLane(1, mine)]} as never
+    expect(civicTransfersAtCap(under, senderIds)).toBe(false)
+    expect(civicTransfersAtCap(at, senderIds)).toBe(true)
+})

package/src/influence/civic-shuttle.ts

@@ -0,0 +1,115 @@
+import type {UInt64} from '@wharfkit/antelope'
+import type {ServerContract} from '../contracts'
+import {getItem} from '../data/catalog'
+import {JOB_QUEUE_CAP} from '../scheduling/jobs'
+import {laneKeyForModule, resolveLaneLoader} from '../scheduling/lanes'
+import {orderedTasks, type ScheduleData} from '../scheduling/schedule'
+import {HoldKind, TaskType} from '../types'
+
+type CargoItem = ServerContract.Types.cargo_item
+type Lane = ServerContract.Types.lane
+type ModuleEntry = ServerContract.Types.module_entry
+
+export const CIVIC_TRANSFER_PER_PLAYER_CAP = 4
+
+export interface CivicShuttleBay {
+    laneKey: number
+    slotIndex: number
+    thrust: number
+    mass: number
+    outputPct: number
+    queued: number
+    full: boolean
+}
+
+export function civicShuttleBays(
+    modules: ModuleEntry[],
+    entityItemId: number,
+    lanes: Lane[]
+): CivicShuttleBay[] {
+    const bays: CivicShuttleBay[] = []
+    for (let slotIndex = 0; slotIndex < modules.length; slotIndex++) {
+        const installed = modules[slotIndex].installed
+        if (!installed) continue
+        if (getItem(installed.item_id).moduleType !== 'loader') continue
+        const laneKey = laneKeyForModule(slotIndex)
+        const loader = resolveLaneLoader(modules, entityItemId, laneKey)
+        const lane = lanes.find((l) => l.lane_key.toNumber() === laneKey)
+        const queued = lane ? lane.schedule.tasks.length : 0
+        bays.push({
+            laneKey,
+            slotIndex,
+            thrust: loader.thrust,
+            mass: loader.mass,
+            outputPct: loader.outputPct,
+            queued,
+            full: queued >= JOB_QUEUE_CAP,
+        })
+    }
+    return bays
+}
+
+// Mirrors worker_lane_key_or_mobility for loaders: first free bay, else the lowest bay.
+export function selectCivicShuttleBay(
+    modules: ModuleEntry[],
+    entityItemId: number,
+    lanes: Lane[]
+): CivicShuttleBay | undefined {
+    const bays = civicShuttleBays(modules, entityItemId, lanes)
+    return bays.find((bay) => bay.queued === 0) ?? bays[0]
+}
+
+export interface PendingCivicTransfer {
+    laneKey: number
+    taskIndex: number
+    senderId: UInt64
+    receiverId: UInt64
+    cargo: CargoItem[]
+    startsAt: Date
+    completesAt: Date
+    isTail: boolean
+    callable: boolean
+}
+
+export function pendingCivicTransfers(entity: ScheduleData): PendingCivicTransfer[] {
+    const tailIndex = new Map<number, number>()
+    for (const l of entity.lanes ?? []) {
+        tailIndex.set(l.lane_key.toNumber(), l.schedule.tasks.length - 1)
+    }
+    const out: PendingCivicTransfer[] = []
+    for (const entry of orderedTasks(entity)) {
+        if (entry.task.type.toNumber() !== TaskType.SHUTTLE) continue
+        const pull = entry.task.couplings.find((c) => c.kind.toNumber() === HoldKind.PULL)
+        const push = entry.task.couplings.find((c) => c.kind.toNumber() === HoldKind.PUSH)
+        if (!pull || !push) continue
+        const isTail = tailIndex.get(entry.laneKey) === entry.taskIndex
+        out.push({
+            laneKey: entry.laneKey,
+            taskIndex: entry.taskIndex,
+            senderId: pull.counterpart.entity_id,
+            receiverId: push.counterpart.entity_id,
+            cargo: entry.task.cargo,
+            startsAt: entry.startsAt,
+            completesAt: entry.completesAt,
+            isTail,
+            callable: isTail && !entry.task.entitygroup,
+        })
+    }
+    return out
+}
+
+// Mirrors civic_transfers_for: the sender side of every shuttle the building holds, by owner.
+export function civicTransfersFrom(
+    entity: ScheduleData,
+    senderIds: Array<UInt64 | string | number>
+): PendingCivicTransfer[] {
+    const owned = new Set(senderIds.map((id) => String(id)))
+    return pendingCivicTransfers(entity).filter((t) => owned.has(String(t.senderId)))
+}
+
+export function civicTransfersAtCap(
+    entity: ScheduleData,
+    senderIds: Array<UInt64 | string | number>
+): boolean {
+    return civicTransfersFrom(entity, senderIds).length >= CIVIC_TRANSFER_PER_PLAYER_CAP
+}