@shipload/sdk 2.0.0-rc11 → 2.0.0-rc12

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@shipload/sdk",
     "description": "SDKs for Shipload",
-    "version": "2.0.0-rc11",
+    "version": "2.0.0-rc12",
     "homepage": "https://github.com/shipload/sdk",
     "license": "MIT",
     "main": "lib/shipload.js",

package/src/capabilities/storage.ts

@@ -1,7 +1,8 @@
-import {UInt32, UInt64, UInt64Type} from '@wharfkit/antelope'
+import {UInt16, UInt32, UInt64, UInt64Type} from '@wharfkit/antelope'
 import {ServerContract} from '../contracts'
 import {StorageCapability} from '../types/capabilities'
 import {getItem} from '../market/items'
+import {INSUFFICIENT_ITEM_QUANTITY} from '../errors'
 
 export interface HasCargo {
     cargo: ServerContract.Types.cargo_item[]
@@ -15,7 +16,13 @@ export interface HasCargomass {
     cargomass: UInt32
 }
 
-export function calcCargoItemMass(item: ServerContract.Types.cargo_item): UInt64 {
+interface MassInput {
+    item_id: UInt16
+    quantity: UInt32
+    modules: ServerContract.Types.module_entry[]
+}
+
+export function calcCargoItemMass(item: MassInput): UInt64 {
     const itemDef = getItem(item.item_id)
     let mass = UInt64.from(itemDef.mass).multiplying(item.quantity)
 
@@ -37,6 +44,14 @@ export function calcCargoMass(entity: HasCargo): UInt64 {
     return mass
 }
 
+export function calcStacksMass(stacks: CargoStack[]): UInt64 {
+    let mass = UInt64.from(0)
+    for (const s of stacks) {
+        mass = mass.adding(calcCargoItemMass(s))
+    }
+    return mass
+}
+
 export function availableCapacity(entity: StorageCapability): UInt64 {
     const cargoMass = calcCargoMass(entity)
     return entity.capacity.gt(cargoMass)
@@ -70,3 +85,78 @@ export function isFull(entity: HasCapacity & HasCargomass): boolean {
 export function isFullFromMass(capacity: UInt64Type, cargoMass: UInt64Type): boolean {
     return UInt64.from(cargoMass).gte(capacity)
 }
+
+export interface CargoStack {
+    item_id: UInt16
+    quantity: UInt32
+    seed?: UInt64
+    modules: ServerContract.Types.module_entry[]
+}
+
+export function cargoItemToStack(item: ServerContract.Types.cargo_item): CargoStack {
+    return {
+        item_id: UInt16.from(item.item_id),
+        quantity: UInt32.from(item.quantity),
+        seed: item.seed,
+        modules: item.modules ?? [],
+    }
+}
+
+export function stackToCargoItem(stack: CargoStack): ServerContract.Types.cargo_item {
+    return ServerContract.Types.cargo_item.from({
+        item_id: stack.item_id,
+        quantity: stack.quantity,
+        seed: stack.seed,
+        modules: stack.modules,
+    })
+}
+
+function seedEquals(a?: UInt64, b?: UInt64): boolean {
+    if (!a && !b) return true
+    if (!a || !b) return false
+    return a.equals(b)
+}
+
+function stackIdentityEqual(a: CargoStack, b: CargoStack): boolean {
+    return a.item_id.equals(b.item_id) && seedEquals(a.seed, b.seed)
+}
+
+export function stackKey(s: CargoStack): string {
+    const seedVal = s.seed ? s.seed.toString() : '0'
+    return `${s.item_id.toNumber()}:${seedVal}`
+}
+
+export function stacksEqual(a: CargoStack, b: CargoStack): boolean {
+    return stackIdentityEqual(a, b) && a.quantity.equals(b.quantity)
+}
+
+export function mergeStacks(stacks: CargoStack[], add: CargoStack): CargoStack[] {
+    const idx = stacks.findIndex((s) => stackIdentityEqual(s, add))
+    if (idx === -1) {
+        return [...stacks, {...add}]
+    }
+    const result = stacks.slice()
+    result[idx] = {
+        ...result[idx],
+        quantity: UInt32.from(result[idx].quantity.adding(add.quantity)),
+    }
+    return result
+}
+
+export function removeFromStacks(stacks: CargoStack[], remove: CargoStack): CargoStack[] {
+    const idx = stacks.findIndex((s) => stackIdentityEqual(s, remove))
+    if (idx === -1) {
+        throw new Error(INSUFFICIENT_ITEM_QUANTITY)
+    }
+    const target = stacks[idx]
+    if (target.quantity.lt(remove.quantity)) {
+        throw new Error(INSUFFICIENT_ITEM_QUANTITY)
+    }
+    const remaining = UInt32.from(target.quantity.subtracting(remove.quantity))
+    if (remaining.equals(UInt32.from(0))) {
+        return [...stacks.slice(0, idx), ...stacks.slice(idx + 1)]
+    }
+    const result = stacks.slice()
+    result[idx] = {...target, quantity: remaining}
+    return result
+}

package/src/data/categories.ts

@@ -20,7 +20,7 @@ const categories: CategoryInfo[] = [
     {
         id: 'precious',
         name: 'Precious Metals',
-        label: 'Precious',
+        label: 'Precious Metal',
         description:
             'Conductive, corrosion-resistant — electronics, energy systems, precision components',
         color: categoryColors.precious,

package/src/derivation/crafting.ts

@@ -4,9 +4,11 @@ import {
     entityRecipes,
     getComponentById,
     getEntityRecipe,
+    getEntityRecipeByItemId,
     getModuleRecipe,
     moduleRecipes,
 } from '../data/recipes'
+import {getStatDefinitions} from './stats'
 import {deriveResourceStats} from './stratum'
 
 export interface StackInput {
@@ -195,3 +197,77 @@ export function blendCargoStacks(
     const blended = allKeys.map((key) => Math.max(1, Math.min(999, blendStacks(decoded, key))))
     return UInt64.from(encodeStats(blended))
 }
+
+export interface RecipeSlotInput {
+    itemId: number
+    category: ResourceCategory | undefined
+    stacks: {quantity: number; seed: bigint}[]
+}
+
+function decodeRawStackToCategoryStats(
+    seed: bigint,
+    category: ResourceCategory
+): Record<string, number> {
+    const raw = deriveResourceStats(seed)
+    const defs = getStatDefinitions(category)
+    const result: Record<string, number> = {}
+    if (defs[0]) result[defs[0].key] = raw.stat1
+    if (defs[1]) result[defs[1].key] = raw.stat2
+    if (defs[2]) result[defs[2].key] = raw.stat3
+    return result
+}
+
+export function computeCraftedOutputSeed(
+    outputItemId: number,
+    slotInputs: RecipeSlotInput[]
+): UInt64 {
+    const component = getComponentById(outputItemId)
+    if (component) {
+        const categoryStacks: CategoryStacks[] = []
+        for (const slot of slotInputs) {
+            if (!slot.category) continue
+            const slotIsComponent = getComponentById(slot.itemId) !== undefined
+            const stacks: StackInput[] = slot.stacks.map((s) => ({
+                quantity: s.quantity,
+                stats: slotIsComponent
+                    ? decodeCraftedItemStats(slot.itemId, s.seed)
+                    : decodeRawStackToCategoryStats(s.seed, slot.category!),
+            }))
+            categoryStacks.push({category: slot.category, stacks})
+        }
+        const stats = computeComponentStats(outputItemId, categoryStacks)
+        const ordered = component.stats.map((statDef) => {
+            const found = stats.find((s) => s.key === statDef.key)
+            return found ? found.value : 0
+        })
+        return UInt64.from(encodeStats(ordered))
+    }
+
+    const entityRecipe = getEntityRecipeByItemId(outputItemId)
+    if (entityRecipe) {
+        const componentStacks: Record<number, {quantity: number; stats: Record<string, number>}[]> =
+            {}
+        for (const slot of slotInputs) {
+            if (slot.category !== undefined) {
+                throw new Error(
+                    `entity recipe ${entityRecipe.id} expects component inputs but slot itemId=${slot.itemId} has category=${slot.category}`
+                )
+            }
+            const list = (componentStacks[slot.itemId] ??= [])
+            for (const s of slot.stacks) {
+                list.push({
+                    quantity: s.quantity,
+                    stats: decodeCraftedItemStats(slot.itemId, s.seed),
+                })
+            }
+        }
+        const stats = computeEntityStats(entityRecipe.id, componentStacks)
+        const ordered = entityRecipe.stats.map((statDef) => {
+            const found = stats.find((s) => s.key === statDef.key)
+            return found ? found.value : 0
+        })
+        return UInt64.from(encodeStats(ordered))
+    }
+
+    throw new Error(`computeCraftedOutputSeed: no recipe found for outputItemId=${outputItemId}`)
+}

package/src/derivation/index.ts

@@ -7,7 +7,6 @@ export {
     getLocationCandidates,
     getDepthThreshold,
     getResourceTier,
-    depthScaleFactor,
     DEPTH_THRESHOLD_T1,
     DEPTH_THRESHOLD_T2,
     DEPTH_THRESHOLD_T3,
@@ -24,5 +23,8 @@ export {
     PLANET_SUBTYPE_INDUSTRIAL,
 } from './resources'
 
+export {RESERVE_TIERS, TIER_ROLL_MAX, rollTier, rollWithinTier} from './tiers'
+export type {ReserveTier, TierRange} from './tiers'
+
 export * from './stats'
 export * from './crafting'

package/src/derivation/resources.ts

@@ -9,7 +9,7 @@ export const DEPTH_THRESHOLD_T5 = 55000
 export const LOCATION_MIN_DEPTH = 500
 export const LOCATION_MAX_DEPTH = 65535
 
-export const YIELD_THRESHOLD = Math.floor(0.003 * 0xffffffff)
+export const YIELD_THRESHOLD = Math.floor(0.001 * 0xffffffff)
 
 export const PLANET_SUBTYPE_GAS_GIANT = 0
 export const PLANET_SUBTYPE_ROCKY = 1
@@ -134,9 +134,3 @@ export function getEligibleResources(
         return stratum >= threshold
     })
 }
-
-export function depthScaleFactor(stratum: number): number {
-    if (stratum <= 1) return 1.0
-    const logScale = Math.log(stratum) / Math.log(65535)
-    return 1.0 + logScale * 2.0
-}

package/src/derivation/stratum.ts

@@ -1,12 +1,8 @@
 import {Bytes, Checksum256, Checksum256Type} from '@wharfkit/antelope'
 import {hash512} from '../utils/hash'
 import {Coordinates, CoordinatesType} from '../types'
-import {
-    depthScaleFactor,
-    getEligibleResources,
-    getResourceWeight,
-    YIELD_THRESHOLD,
-} from './resources'
+import {getEligibleResources, getResourceWeight, YIELD_THRESHOLD} from './resources'
+import {RESERVE_TIERS, rollTier, rollWithinTier} from './tiers'
 
 export interface StratumInfo {
     itemId: number
@@ -39,9 +35,10 @@ export function deriveStratum(
 
     let reserve = 0
     if (rawReserve <= YIELD_THRESHOLD) {
-        const baseReserve = (rawReserve % 333) + 1
-        const scale = depthScaleFactor(stratum)
-        reserve = Math.floor(baseReserve * scale)
+        const tierRoll = ((bytes[18] << 8) | bytes[19]) >>> 0
+        const withinRoll = ((bytes[20] << 8) | bytes[21]) >>> 0
+        const tier = rollTier(tierRoll, stratum)
+        reserve = rollWithinTier(withinRoll, RESERVE_TIERS[tier])
     }
 
     if (reserve === 0) return {itemId: 0, seed: 0n, richness: 0, reserve: 0}
@@ -105,11 +102,12 @@ export function deriveResourceStats(seed: bigint): ResourceStats {
         (hashBytes[offset] * 0x1000000 +
             (hashBytes[offset + 1] << 16) +
             (hashBytes[offset + 2] << 8) +
-            hashBytes[offset + 3]) >>> 0
+            hashBytes[offset + 3]) >>>
+        0
 
     const weibull = (raw: number): number => {
         const u = raw / 4294967296
-        let x = 0.27 * Math.sqrt(-Math.log(1 - u))
+        let x = 0.24 * Math.sqrt(-Math.log(1 - u))
         if (x > 1) x = 1
         let val = Math.floor(x * 999) + 1
         if (val > 999) val = 999

package/src/derivation/tiers.ts

@@ -0,0 +1,54 @@
+export type ReserveTier = 'small' | 'medium' | 'large' | 'massive' | 'motherlode'
+
+export interface TierRange {
+    min: number
+    max: number
+}
+
+export const RESERVE_TIERS: Record<ReserveTier, TierRange> = {
+    small: {min: 15, max: 60},
+    medium: {min: 100, max: 200},
+    large: {min: 400, max: 700},
+    massive: {min: 1000, max: 2500},
+    motherlode: {min: 4000, max: 10000},
+}
+
+const SHALLOW_THRESHOLDS = {
+    small: 0.8,
+    medium: 0.991946,
+    large: 0.999946,
+    massive: 0.999996,
+}
+
+const DEEP_THRESHOLDS = {
+    small: 0.5,
+    medium: 0.95892,
+    large: 0.99892,
+    massive: 0.99992,
+}
+
+export const TIER_ROLL_MAX = 0x10000 // 65536
+
+function lerp(a: number, b: number, t: number): number {
+    return a + (b - a) * t
+}
+
+export function rollTier(tierRoll: number, stratum: number): ReserveTier {
+    const d = Math.min(stratum, 65535) / 65535
+    const smallMax = lerp(SHALLOW_THRESHOLDS.small, DEEP_THRESHOLDS.small, d) * TIER_ROLL_MAX
+    const mediumMax = lerp(SHALLOW_THRESHOLDS.medium, DEEP_THRESHOLDS.medium, d) * TIER_ROLL_MAX
+    const largeMax = lerp(SHALLOW_THRESHOLDS.large, DEEP_THRESHOLDS.large, d) * TIER_ROLL_MAX
+    const massiveMax = lerp(SHALLOW_THRESHOLDS.massive, DEEP_THRESHOLDS.massive, d) * TIER_ROLL_MAX
+
+    if (tierRoll < smallMax) return 'small'
+    if (tierRoll < mediumMax) return 'medium'
+    if (tierRoll < largeMax) return 'large'
+    if (tierRoll < massiveMax) return 'massive'
+    return 'motherlode'
+}
+
+export function rollWithinTier(withinRoll: number, range: TierRange): number {
+    const u = withinRoll / 65535
+    const skewed = u * u
+    return Math.floor(range.min + skewed * (range.max - range.min))
+}

package/src/errors.ts

@@ -44,3 +44,8 @@ export const SHIP_CARGO_NOT_LOADED = 'Cannot unload cargo that is not loaded.'
 export const WAREHOUSE_NOT_FOUND = 'Cannot find warehouse for given id.'
 export const WAREHOUSE_ALREADY_AT_LOCATION = 'Warehouse already exists at this location.'
 export const WAREHOUSE_CAPACITY_EXCEEDED = 'Warehouse capacity would be exceeded.'
+export const ENTITY_CAPACITY_EXCEEDED = 'Entity cargo capacity would be exceeded.'
+export const RECIPE_INPUTS_INSUFFICIENT = 'Insufficient inputs for recipe.'
+export const RECIPE_INPUTS_INVALID = 'Input cargo does not match recipe requirements.'
+export const RECIPE_INPUTS_EXCESS = 'Provided inputs exceed recipe requirements.'
+export const RECIPE_INPUTS_MIXED = 'All stacks for a recipe input must be the same resource.'

package/src/index-module.ts

@@ -66,7 +66,6 @@ export {
     getLocationCandidates,
     getDepthThreshold,
     getResourceTier,
-    depthScaleFactor,
     DEPTH_THRESHOLD_T1,
     DEPTH_THRESHOLD_T2,
     DEPTH_THRESHOLD_T3,
@@ -84,6 +83,9 @@ export {
 
 export type {StratumInfo, ResourceStats} from './derivation'
 
+export {RESERVE_TIERS, TIER_ROLL_MAX, rollTier, rollWithinTier} from './derivation'
+export type {ReserveTier, TierRange} from './derivation'
+
 export {getStatDefinitions, getStatName, resolveStats} from './derivation'
 export type {StatDefinition, NamedStats} from './derivation'
 
@@ -135,7 +137,12 @@ export type {HasCargo} from './entities/inventory-accessor'
 export * as cargoUtils from './entities/cargo-utils'
 export type {CargoData} from './entities/cargo-utils'
 
-export {projectEntity, projectEntityAt, createProjectedEntity} from './scheduling/projection'
+export {
+    createProjectedEntity,
+    projectEntity,
+    projectEntityAt,
+    validateSchedule,
+} from './scheduling/projection'
 export type {Projectable, ProjectedEntity} from './scheduling/projection'
 
 export * from './types/capabilities'
@@ -230,8 +237,9 @@ export {
     blendCrossGroup,
     categoryItemMass,
     computeInputMass,
+    computeCraftedOutputSeed,
 } from './derivation/crafting'
-export type {StackInput, CategoryStacks} from './derivation/crafting'
+export type {StackInput, CategoryStacks, RecipeSlotInput} from './derivation/crafting'
 
 export {computeContainerCapabilities, computeContainerT2Capabilities} from './entities/container'
 

package/src/market/items.ts

@@ -1,9 +1,14 @@
 import {UInt16, UInt16Type} from '@wharfkit/antelope'
 import {Item} from '../types'
 import itemsData from '../data/items.json'
+import {computeInputMass} from '../derivation/crafting'
+import {getComponentById, getEntityRecipeByItemId, getModuleRecipeByItemId} from '../data/recipes'
 
-const items: Item[] = itemsData.map((g) =>
-    Item.from({
+const itemsById: Map<number, Item> = new Map()
+const synthesizedCache: Map<number, Item> = new Map()
+
+for (const g of itemsData) {
+    const item = Item.from({
         id: g.id,
         name: g.name,
         description: g.description,
@@ -12,19 +17,73 @@ const items: Item[] = itemsData.map((g) =>
         tier: g.tier,
         color: g.color,
     })
-)
+    itemsById.set(item.id.toNumber(), item)
+}
+
+export const itemIds = Array.from(itemsById.values(), (i) => i.id)
+
+interface RecipeSource {
+    name: string
+    description: string
+    mass: number
+    color: string
+}
+
+function synthesizeItem(id: number, source: RecipeSource): Item {
+    return Item.from({
+        id,
+        name: source.name,
+        description: source.description,
+        mass: source.mass,
+        category: 'metal',
+        tier: 't1',
+        color: source.color,
+    })
+}
+
+function synthesizeFromRecipes(id: number): Item | undefined {
+    const component = getComponentById(id)
+    if (component) return synthesizeItem(id, component)
 
-export const itemIds = items.map((i) => i.id)
+    const entityRecipe = getEntityRecipeByItemId(id)
+    if (entityRecipe) {
+        return synthesizeItem(id, {
+            ...entityRecipe,
+            mass: computeInputMass(entityRecipe.id, 'entity'),
+        })
+    }
+
+    const moduleRecipe = getModuleRecipeByItemId(id)
+    if (moduleRecipe) {
+        return synthesizeItem(id, {
+            ...moduleRecipe,
+            mass: computeInputMass(moduleRecipe.id, 'module'),
+        })
+    }
+
+    return undefined
+}
 
 export function getItem(itemId: UInt16Type): Item {
-    const id = UInt16.from(itemId)
-    const item = items.find((i) => i.id.equals(id))
-    if (!item) {
-        throw new Error(`Item with id ${id} not found`)
+    const id = UInt16.from(itemId).toNumber()
+    const existing = itemsById.get(id) ?? synthesizedCache.get(id)
+    if (existing) return existing
+
+    const synthesized = synthesizeFromRecipes(id)
+    if (synthesized) {
+        synthesizedCache.set(id, synthesized)
+        return synthesized
     }
-    return item
+
+    throw new Error(`Item with id ${id} not found`)
 }
 
 export function getItems(): Item[] {
-    return items
+    return Array.from(itemsById.values())
+}
+
+export function registerItem(item: Item): void {
+    const id = item.id.toNumber()
+    itemsById.set(id, item)
+    synthesizedCache.delete(id)
 }