@shipload/sdk 1.0.0-next.75 → 1.0.0-next.76

package/src/data/task-types.json

@@ -179,6 +179,15 @@
       "isTerminal": false,
       "capsPlan": false,
       "cargoEffectResolve": false
+    },
+    {
+      "type": 23,
+      "positionBound": false,
+      "mobility": false,
+      "consumer": false,
+      "isTerminal": false,
+      "capsPlan": false,
+      "cargoEffectResolve": true
     }
   ]
 }

package/src/derivation/capabilities.test.ts

@@ -10,7 +10,9 @@ import {
     computeLoaderCapabilities,
     computeBaseCapacity,
     computeContainerCapabilities,
+    computeStructureBaseCapacity,
     applyCapacityTier,
+    CARGO_BAY_CAPACITY_TIER_PCT,
     GATHERER_YIELD_TIER_TABLE,
     ENGINE_THRUST_TIER_PCT,
     GENERATOR_CAPACITY_TIER_PCT,
@@ -34,6 +36,8 @@ import {applySlotMultiplier, U16_MAX} from '../entities/slot-multiplier'
 import {getItem} from '../data/catalog'
 import {encodeStats} from './crafting'
 import {
+    ITEM_CONTAINER_T1_PACKED,
+    ITEM_CONTAINER_T2_PACKED,
     ITEM_EXTRACTOR_T2_PACKED,
     ITEM_FACTORY_T2_PACKED,
     ITEM_MASS_DRIVER_T1_PACKED,
@@ -74,9 +78,9 @@ function makeBuilderStats(resonance: number, fineness: number): bigint {
     return encodeStats([resonance, fineness])
 }
 
-test('computeBaseCapacity uses container formula for all container-class entities', () => {
+test('computeBaseCapacity uses the structure formula for structure entities', () => {
     const stats = {strength: 300, hardness: 400, density: 100}
-    const base = computeContainerCapabilities(stats).capacity
+    const base = computeStructureBaseCapacity(stats)
     for (const itemId of [
         ITEM_EXTRACTOR_T2_PACKED,
         ITEM_FACTORY_T2_PACKED,
@@ -89,6 +93,25 @@ test('computeBaseCapacity uses container formula for all container-class entitie
     }
 })
 
+test('containers hold what a Storage module of their tier holds and weigh their packed mass', () => {
+    for (const [base, t1, t2, t2Mass] of [
+        [213, 206_600, 227_260, 27_698],
+        [500, 345_687, 380_255, 23_250],
+    ]) {
+        const stats = {strength: base, density: base, hardness: base}
+        expect(computeBaseCapacity(ITEM_CONTAINER_T1_PACKED, stats)).toBe(t1)
+        expect(computeBaseCapacity(ITEM_CONTAINER_T2_PACKED, stats)).toBe(t2)
+        expect(computeContainerCapabilities(stats, ITEM_CONTAINER_T2_PACKED).hullmass).toBe(t2Mass)
+        expect(t2).toBe(
+            Math.floor(
+                (computeContainerCapabilities(stats).capacity *
+                    moduleTierPct(CARGO_BAY_CAPACITY_TIER_PCT, 2)) /
+                    100
+            )
+        )
+    }
+})
+
 test('computeBaseCapacity uses ship-hull formula for every ship-class entity', () => {
     const stats = {strength: 300, hardness: 400, density: 100}
     const expected = computeBaseCapacity(ITEM_SHIP_T1_PACKED, stats)

package/src/derivation/capabilities.ts

@@ -322,6 +322,12 @@ const CAPACITY_FN_BY_NAME: Partial<
     depot: (stats) => computeDepotHullCapabilities(stats).capacity,
     workshop: (stats) => computeWorkshopHullCapabilities(stats).capacity,
     container: (stats) => computeContainerCapabilities(stats).capacity,
+    structure: computeStructureBaseCapacity,
+}
+
+export function computeStructureBaseCapacity(stats: Record<string, number>): number {
+    const statSum = (stats.strength ?? 0) + (stats.hardness ?? 0)
+    return Math.floor(220000 * 6 ** (statSum / 1998.0))
 }
 
 export function computeBaseCapacity(itemId: number, stats: Record<string, number>): number {
@@ -333,6 +339,10 @@ export function computeBaseCapacity(itemId: number, stats: Record<string, number
         const capacityFn = fnName ? CAPACITY_FN_BY_NAME[fnName] : undefined
         if (!capacityFn) return 0
         base = capacityFn(stats)
+        if (fnName === 'container') {
+            const pct = moduleTierPct(CARGO_BAY_CAPACITY_TIER_PCT, getItem(itemId).tier)
+            return clampUint32(Math.floor((base * pct) / 100))
+        }
     }
     return applyCapacityTier(base, getItem(itemId).tier)
 }
@@ -692,14 +702,17 @@ export function computeEntityCapabilities(
     return result
 }
 
-export function computeContainerCapabilities(stats: Record<string, number>): {
+export function computeContainerCapabilities(
+    stats: Record<string, number>,
+    itemId: number = ITEM_CONTAINER_T1_PACKED
+): {
     hullmass: number
     capacity: number
 } {
     const statSum = (stats.strength ?? 0) + (stats.hardness ?? 0)
     const exponent = statSum / 1998.0
     return {
-        hullmass: computeBaseHullmass(ITEM_CONTAINER_T1_PACKED, stats),
-        capacity: Math.floor(220000 * 6 ** exponent),
+        hullmass: computeBaseHullmass(itemId, stats),
+        capacity: Math.floor(141000 * 6 ** exponent),
     }
 }

package/src/derivation/capacity-fn-registry.ts

@@ -1,6 +1,13 @@
 import {getBaseCapacityFnName} from '../data/kind-registry'
 
-export const CAPACITY_FN_NAMES = ['ship', 'warehouse', 'depot', 'container', 'workshop'] as const
+export const CAPACITY_FN_NAMES = [
+    'ship',
+    'warehouse',
+    'depot',
+    'container',
+    'structure',
+    'workshop',
+] as const
 
 export type CapacityFnName = (typeof CAPACITY_FN_NAMES)[number]
 

package/src/derivation/reserve-regen.ts

@@ -10,13 +10,6 @@ function toNumber(value: UInt32 | number): number {
     return typeof value === 'number' ? value : Number(value)
 }
 
-function slotsBetween(now: BlockTimestamp, last: BlockTimestamp): number {
-    const nowMs = now.toMilliseconds()
-    const lastMs = last.toMilliseconds()
-    if (nowMs <= lastMs) return 0
-    return Math.floor((nowMs - lastMs) / 500)
-}
-
 export function getEffectiveReserve(
     row: EffectiveReserveInput,
     now: BlockTimestamp,
@@ -27,8 +20,11 @@ export function getEffectiveReserve(
     if (remaining >= max) return max
     const epochSlots = epochSeconds * 2
     if (epochSlots === 0) return remaining
-    const elapsed = slotsBetween(now, row.last_block)
-    const regen = Math.floor((max * elapsed) / epochSlots)
+    const nowSlot = Number(now.value)
+    const lastSlot = Number(row.last_block.value)
+    if (nowSlot <= lastSlot) return remaining
+    const regen =
+        Math.floor((max * nowSlot) / epochSlots) - Math.floor((max * lastSlot) / epochSlots)
     const effective = remaining + regen
     return effective >= max ? max : effective
 }

package/src/derivation/stratum.ts

@@ -67,7 +67,7 @@ export function deriveStratum(
         }
     }
 
-    const tierRoll = ((bytes[18] << 8) | bytes[19]) >>> 0
+    const tierRoll = ((bytes[16] << 24) | (bytes[17] << 16) | (bytes[18] << 8) | bytes[19]) >>> 0
     const withinRoll = ((bytes[20] << 8) | bytes[21]) >>> 0
     const tier = rollTier(tierRoll, stratum)
     const selected = getItem(selectedItemId)

package/src/derivation/tiers.ts

@@ -29,7 +29,7 @@ const DEEP_THRESHOLDS = {
     massive: 0.99992,
 }
 
-export const TIER_ROLL_MAX = 0x10000 // 65536
+export const TIER_ROLL_MAX = 0x1_0000_0000
 
 function lerp(a: number, b: number, t: number): number {
     return a + (b - a) * t

package/src/derivation/upgrades.ts

@@ -3,10 +3,11 @@ import type {Recipe} from '../data/recipes-runtime'
 
 const bySource = new Map<number, Recipe[]>()
 for (const r of recipes as Recipe[]) {
-    if (r.sourceSubclass === undefined) continue
-    const list = bySource.get(r.sourceSubclass) ?? []
-    list.push(r)
-    bySource.set(r.sourceSubclass, list)
+    for (const source of r.sourceSubclasses ?? []) {
+        const list = bySource.get(source) ?? []
+        list.push(r)
+        bySource.set(source, list)
+    }
 }
 
 export function eligibleUpgrades(entityItemId: number): Recipe[] {

package/src/index-module.ts

@@ -71,6 +71,7 @@ export {
     OMITTED_REASONS,
 } from './managers/shuttle'
 export type {
+    ShuttleMissingItem,
     ShuttleMode,
     ShuttleOption,
     ShuttleOptions,
@@ -569,6 +570,7 @@ export {
     computeStorageCapabilities,
     computeBatteryCapabilities,
     computeContainerCapabilities,
+    computeStructureBaseCapacity,
     computeWarpCapabilities,
     computeLauncherCapabilities,
     computeBaseCapacity,
@@ -689,6 +691,7 @@ export {
     computeBaseCapacityWarehouse,
     computeBaseCapacityDepot,
     computeBaseCapacityContainer,
+    computeBaseCapacityStructure,
     computeEngineThrust,
     computeEngineDrain,
     computeTravelDrain,

package/src/influence/influence.test.ts

@@ -136,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(72)
     })
 
     test('the retired Workshop has no decomposition entry', () => {

package/src/managers/actions.ts

@@ -120,15 +120,16 @@ function calcDistance(origin: CoordinatesType, destination: CoordinatesType): bi
 }
 
 function calcCargoItemMassUint32(item: ServerContract.ActionParams.Type.cargo_item): bigint {
-    let mass = toUint32(BigInt(getItem(item.item_id).mass) * toUint32(toBigInt(item.quantity)))
+    let unitMass = BigInt(getItem(item.item_id).mass)
 
     for (const mod of item.modules) {
         if (mod.installed) {
-            mass = toUint32(mass + BigInt(getItem(mod.installed.item_id).mass))
+            unitMass += BigInt(getItem(mod.installed.item_id).mass)
         }
     }
 
-    return mass
+    const mass = unitMass * toBigInt(item.quantity)
+    return mass > UINT32_MAX_BIGINT ? UINT32_MAX_BIGINT : mass
 }
 
 function calcPayloadMass(items: ServerContract.ActionParams.Type.cargo_item[]): bigint {
@@ -1051,9 +1052,11 @@ export class ActionsManager extends BaseManager {
         })
     }
 
-    closeepoch(epoch: UInt64Type): Action {
+    closeepoch(oracleId: NameType, epoch: UInt64Type, entropy: Checksum256Type): Action {
         return this.server.action('closeepoch', {
+            oracle_id: Name.from(oracleId),
             epoch: UInt64.from(epoch),
+            entropy: Checksum256.from(entropy),
         })
     }
 
@@ -1108,27 +1111,17 @@ export class ActionsManager extends BaseManager {
         entityId: UInt64Type,
         location: CoordinatesType,
         bundle: ServerContract.ActionParams.Type.cargo_item[]
-    ): Action {
-        return this.platform.action('contribute', {
-            game: this.server.account,
+    ): Action[] {
+        const args = {
             player: Name.from(player),
             entity_id: UInt64.from(entityId),
             x: Int64.from(location.x),
             y: Int64.from(location.y),
             bundle,
-        })
-    }
-
-    // addcontrib asserts the citizenship rows exist, so naturalize must precede contribute.
-    firstContribution(
-        player: NameType,
-        entityId: UInt64Type,
-        location: CoordinatesType,
-        bundle: ServerContract.ActionParams.Type.cargo_item[]
-    ): Action[] {
+        }
         return [
-            this.naturalize(player, location),
-            this.contribute(player, entityId, location, bundle),
+            this.platform.action('contribute', {game: this.server.account, ...args}),
+            this.server.action('contribute', args),
         ]
     }
 

package/src/managers/entities.test.ts

@@ -0,0 +1,23 @@
+import {describe, expect, it} from 'bun:test'
+import {UInt64} from '@wharfkit/antelope'
+import {EntitiesManager} from './entities'
+
+function managerWith(getImpl: (key: unknown) => Promise<unknown>) {
+    const table = () => ({get: getImpl})
+    const ctx = {server: {table}} as never
+    return new EntitiesManager(ctx)
+}
+
+describe('EntitiesManager.getHullStats', () => {
+    it('reads the encoded stats off the raw entity row', async () => {
+        const m = managerWith(async () => ({stats: UInt64.from('123456789')}))
+        const stats = await m.getHullStats(23)
+        expect(stats.equals(UInt64.from('123456789'))).toBe(true)
+    })
+
+    it('returns zero when the chain has no row for the id', async () => {
+        const m = managerWith(async () => undefined)
+        const stats = await m.getHullStats(23)
+        expect(stats.equals(UInt64.from(0))).toBe(true)
+    })
+})

package/src/managers/entities.ts

@@ -1,4 +1,4 @@
-import {Name, type NameType, type UInt64Type} from '@wharfkit/antelope'
+import {Name, UInt64, type NameType, type UInt64Type} from '@wharfkit/antelope'
 import {BaseManager} from './base'
 import {Entity} from '../entities/entity'
 import type {EntityTypeName} from '../data/kind-registry'
@@ -43,6 +43,13 @@ export class EntitiesManager extends BaseManager {
         return rows.filter((row) => wanted.equals(row.kind))
     }
 
+    async getHullStats(id: UInt64Type): Promise<UInt64> {
+        const row = (await this.server.table('entity').get(UInt64.from(id))) as
+            | ServerContract.Types.entity_row
+            | undefined
+        return row?.stats ?? UInt64.from(0)
+    }
+
     async getSummaries(
         owner: NameType | ServerContract.Types.player_row,
         kind?: EntityTypeName

package/src/managers/shuttle.test.ts

@@ -144,6 +144,7 @@ describe('ShuttleManager', () => {
                         need: null,
                         cap: null,
                         task_type: null,
+                        missing: [],
                     },
                 }),
             ],
@@ -153,6 +154,67 @@ describe('ShuttleManager', () => {
         expect(out.options[0].blocked?.at?.getTime()).toBe(2000 * 1000)
     })
 
+    it('an inputs rejection lists the missing items, merged by item', async () => {
+        const cargo = (item_id: number, stats: number, quantity: number) => ({
+            item_id,
+            stats,
+            modules: [],
+            quantity,
+            entity_id: null,
+        })
+        const m = managerWithReadonly(async () => ({
+            options: [
+                rawOption({
+                    rejection: {
+                        reason: 'Insufficient inputs for recipe.',
+                        at: t(2000),
+                        until: null,
+                        have: null,
+                        need: null,
+                        cap: null,
+                        task_type: null,
+                        missing: [cargo(101, 1, 10), cargo(201, 0, 4), cargo(101, 2, 5)],
+                    },
+                }),
+            ],
+        }))
+        const out = await m.craft({
+            shipId: 5,
+            workshopId: 9,
+            recipeId: 10001,
+            quantity: 1,
+            inputs: [],
+            candidates: [],
+        })
+        const blocked = out.options[0].blocked!
+        expect(blocked.code).toBe('inputs-unavailable')
+        expect(blocked.missing).toEqual([
+            {itemId: 101, quantity: 15},
+            {itemId: 201, quantity: 4},
+        ])
+    })
+
+    it('a rejection with nothing missing carries no missing list', async () => {
+        const m = managerWithReadonly(async () => ({
+            options: [
+                rawOption({
+                    rejection: {
+                        reason: 'fabricator queue is full',
+                        at: t(2000),
+                        until: null,
+                        have: null,
+                        need: null,
+                        cap: null,
+                        task_type: null,
+                        missing: [],
+                    },
+                }),
+            ],
+        }))
+        const out = await m.store({shipId: 5, depotId: 9, items: [], candidates: []})
+        expect(out.options[0].blocked?.missing).toBeUndefined()
+    })
+
     it('a never-shuttle reason is omitted', async () => {
         const m = managerWithReadonly(async () => ({
             options: [
@@ -167,6 +229,7 @@ describe('ShuttleManager', () => {
                         need: null,
                         cap: null,
                         task_type: null,
+                        missing: [],
                     },
                 }),
             ],
@@ -184,6 +247,7 @@ describe('ShuttleManager', () => {
             need: 200,
             cap: 1000,
             task_type: null,
+            missing: [],
         }
         const m = managerWithReadonly(async () => ({
             options: [
@@ -206,6 +270,7 @@ describe('ShuttleManager', () => {
             need: null,
             cap: null,
             task_type: 3,
+            missing: [],
         }
         const m = managerWithReadonly(async () => ({
             options: [
@@ -368,6 +433,7 @@ describe('ShuttleManager', () => {
             need: null,
             cap: null,
             task_type: null,
+            missing: [],
         })
         const m = managerWithReadonly(async () => ({
             options: [
@@ -394,6 +460,7 @@ describe('ShuttleManager', () => {
             need: null,
             cap: null,
             task_type: null,
+            missing: [],
         }
         const m = managerWithReadonly(async () => ({
             options: [

package/src/managers/shuttle.ts

@@ -42,6 +42,11 @@ export type ShuttleReasonCode =
     | 'not-ready'
     | 'unknown'
 
+export interface ShuttleMissingItem {
+    itemId: number
+    quantity: number
+}
+
 export interface ShuttleReason {
     code: ShuttleReasonCode
     reason: string
@@ -51,6 +56,7 @@ export interface ShuttleReason {
     need?: number
     cap?: number
     taskType?: number
+    missing?: ShuttleMissingItem[]
 }
 
 export interface ShuttleOption {
@@ -166,6 +172,16 @@ function toNum(v: {toNumber(): number} | undefined): number | undefined {
     return v === undefined ? undefined : v.toNumber()
 }
 
+function mapMissing(items: ServerContract.Types.cargo_item[]): ShuttleMissingItem[] | undefined {
+    if (items.length === 0) return undefined
+    const byItem = new Map<number, number>()
+    for (const item of items) {
+        const id = item.item_id.toNumber()
+        byItem.set(id, (byItem.get(id) ?? 0) + item.quantity.toNumber())
+    }
+    return [...byItem].map(([itemId, quantity]) => ({itemId, quantity}))
+}
+
 function mapReason(r: ServerContract.Types.shuttle_rejection): ShuttleReason {
     return {
         code: shuttleReasonCode(r.reason),
@@ -176,6 +192,7 @@ function mapReason(r: ServerContract.Types.shuttle_rejection): ShuttleReason {
         need: toNum(r.need),
         cap: toNum(r.cap),
         taskType: toNum(r.task_type),
+        missing: mapMissing(r.missing),
     }
 }
 

package/src/nft/description.ts

@@ -71,6 +71,11 @@ export function computeBaseCapacityShip(stats: bigint): number {
 }
 
 export function computeBaseCapacityContainer(stats: bigint): number {
+    const s = decodeStat(stats, 0) + decodeStat(stats, 2)
+    return Math.floor(141_000 * 6 ** (s / 1998))
+}
+
+export function computeBaseCapacityStructure(stats: bigint): number {
     const s = decodeStat(stats, 0) + decodeStat(stats, 2)
     return Math.floor(220_000 * 6 ** (s / 1998))
 }
@@ -95,6 +100,7 @@ const CAPACITY_FN_BY_NAME: Record<CapacityFnName, (stats: bigint) => number> = {
     warehouse: computeBaseCapacityWarehouse,
     workshop: computeBaseCapacityWorkshop,
     container: computeBaseCapacityContainer,
+    structure: computeBaseCapacityStructure,
     depot: computeBaseCapacityDepot,
 }
 

package/src/resolution/resolve-item.test.ts

@@ -4,7 +4,7 @@ import {resolveItem} from './resolve-item'
 import {encodeStats} from '../derivation/crafting'
 import {
     computeBaseHullmass,
-    computeContainerCapabilities,
+    computeStructureBaseCapacity,
     applyCapacityTier,
 } from '../derivation/capabilities'
 import {getItem} from '../data/catalog'
@@ -20,24 +20,24 @@ function hullStats(strength: number, density: number, hardness: number): UInt64
     return UInt64.from(encodeStats([strength, density, hardness]).toString())
 }
 
-const CONTAINER_ENTITIES = [
+const STRUCTURE_ENTITIES = [
     ['factory', ITEM_FACTORY_T2_PACKED],
     ['extractor', ITEM_EXTRACTOR_T2_PACKED],
     ['mass driver', ITEM_MASS_DRIVER_T1_PACKED],
     ['mass catcher', ITEM_MASS_CATCHER_T1_PACKED],
 ] as const
 
-for (const [label, itemId] of CONTAINER_ENTITIES) {
-    test(`resolveItem resolves ${label} hull capacity via container formula`, () => {
+for (const [label, itemId] of STRUCTURE_ENTITIES) {
+    test(`resolveItem resolves ${label} hull capacity via structure formula`, () => {
         const stats = hullStats(300, 100, 400)
         const resolved = resolveItem(UInt16.from(itemId), stats)
         const hull = resolved.attributes?.find((g) => g.capability === 'Hull')
         const capacity = hull?.attributes.find((a) => a.label === 'Capacity')?.value
-        const base = computeContainerCapabilities({
+        const base = computeStructureBaseCapacity({
             strength: 300,
             hardness: 400,
             density: 100,
-        }).capacity
+        })
         expect(capacity).toBe(applyCapacityTier(base, getItem(itemId).tier))
     })
 }