@shipload/sdk 1.0.0-next.18 → 1.0.0-next.19

package/src/managers/construction-types.ts

@@ -0,0 +1,47 @@
+import type {Name, UInt32, UInt64} from '@wharfkit/antelope'
+import type {ServerContract} from '../contracts'
+import type {Item} from '../types'
+import type {Recipe} from '../data/recipes-runtime'
+import type {PlotProgress} from './plot'
+
+export type BuildState = 'initializing' | 'accepting' | 'ready' | 'finalizing'
+
+export type FinalizerCapability = 'crafter'
+
+export interface BuildableTarget {
+    entityId: UInt64
+    ownerName: Name
+    coordinates: ServerContract.Types.coordinates
+    targetItemId: number
+    targetItem: Item
+    state: BuildState
+    recipe: Recipe
+    progress: PlotProgress
+    finalizeAction: Name
+    finalizerCapability: FinalizerCapability
+    activeTask?: ServerContract.Types.task
+}
+
+export interface SourceEntityRef {
+    entityId: UInt64
+    name: string
+    hasLoaders: boolean
+    loaderCount: number
+    loaderTotalMass: number
+    relevantCargo: SourceCargoStack[]
+}
+
+export interface SourceCargoStack {
+    itemId: number
+    item: Item
+    available: number
+    plotNeeds: number
+}
+
+export interface FinalizerEntityRef {
+    entityId: UInt64
+    name: string
+    capability: FinalizerCapability
+    crafterSpeed: number
+    estimatedDuration: UInt32
+}

package/src/managers/construction.ts

@@ -0,0 +1,147 @@
+import type {UInt32} from '@wharfkit/antelope'
+import {BaseManager} from './base'
+import type {ServerContract} from '../contracts'
+import {PlotManager} from './plot'
+import {getItem} from '../data/catalog'
+import {calc_craft_duration} from '../capabilities/crafting'
+import type {
+    BuildableTarget,
+    FinalizerEntityRef,
+    SourceCargoStack,
+    SourceEntityRef,
+} from './construction-types'
+
+const CONSTRUCTION_KINDS = new Set<string>(['plot'])
+
+export class ConstructionManager extends BaseManager {
+    private readonly plot = new PlotManager(this.context)
+
+    getTarget(
+        entity: ServerContract.Types.entity_row,
+        cargo: ServerContract.Types.cargo_row[],
+        activeTask?: ServerContract.Types.task
+    ): BuildableTarget | null {
+        const kind = entity.kind.toString()
+        if (kind === 'plot') {
+            return this.plot.buildableTarget(entity, cargo, activeTask)
+        }
+        return null
+    }
+
+    eligibleSources(
+        target: BuildableTarget,
+        entities: ServerContract.Types.entity_row[],
+        cargo: ServerContract.Types.cargo_row[]
+    ): SourceEntityRef[] {
+        return partitionSources(target, entities, cargo).eligible
+    }
+
+    unreachableSources(
+        target: BuildableTarget,
+        entities: ServerContract.Types.entity_row[],
+        cargo: ServerContract.Types.cargo_row[]
+    ): SourceEntityRef[] {
+        return partitionSources(target, entities, cargo).unreachable
+    }
+
+    partitionSources(
+        target: BuildableTarget,
+        entities: ServerContract.Types.entity_row[],
+        cargo: ServerContract.Types.cargo_row[]
+    ): {eligible: SourceEntityRef[]; unreachable: SourceEntityRef[]} {
+        return partitionSources(target, entities, cargo)
+    }
+
+    eligibleFinalizers(
+        target: BuildableTarget,
+        entities: ServerContract.Types.entity_row[]
+    ): FinalizerEntityRef[] {
+        const out: FinalizerEntityRef[] = []
+        for (const entity of entities) {
+            if (!entity.owner.equals(target.ownerName)) continue
+            if (entity.id.equals(target.entityId)) continue
+            if (!coordsEqual(entity.coordinates, target.coordinates)) continue
+            const speed = entity.crafter?.speed.toNumber()
+            if (speed === undefined) continue
+            out.push({
+                entityId: entity.id,
+                name: entity.id.toString(),
+                capability: 'crafter',
+                crafterSpeed: speed,
+                estimatedDuration: this.estimateFinalizeDuration(target, speed),
+            })
+        }
+        return out.sort((a, b) => a.estimatedDuration.value - b.estimatedDuration.value)
+    }
+
+    estimateFinalizeDuration(target: BuildableTarget, crafterSpeed: number): UInt32 {
+        return calc_craft_duration(crafterSpeed, target.progress.massRequired)
+    }
+
+    static isConstructionKind(kind: string): boolean {
+        return CONSTRUCTION_KINDS.has(kind)
+    }
+}
+
+function coordsEqual(
+    a: ServerContract.Types.coordinates,
+    b: ServerContract.Types.coordinates
+): boolean {
+    return a.x.equals(b.x) && a.y.equals(b.y)
+}
+
+function matchRelevantCargo(
+    entity: ServerContract.Types.entity_row,
+    target: BuildableTarget,
+    cargo: ServerContract.Types.cargo_row[]
+): SourceCargoStack[] {
+    const quantityByItemId = new Map<number, number>()
+    for (const c of cargo) {
+        if (!c.entity_id.equals(entity.id)) continue
+        const id = c.item_id.toNumber()
+        quantityByItemId.set(id, (quantityByItemId.get(id) ?? 0) + c.quantity.toNumber())
+    }
+
+    const out: SourceCargoStack[] = []
+    for (const row of target.progress.rows) {
+        if (row.missing === 0) continue
+        const available = quantityByItemId.get(row.itemId) ?? 0
+        if (available === 0) continue
+        out.push({
+            itemId: row.itemId,
+            item: getItem(row.itemId),
+            available,
+            plotNeeds: row.missing,
+        })
+    }
+    return out
+}
+
+function partitionSources(
+    target: BuildableTarget,
+    entities: ServerContract.Types.entity_row[],
+    cargo: ServerContract.Types.cargo_row[]
+): {eligible: SourceEntityRef[]; unreachable: SourceEntityRef[]} {
+    const eligible: SourceEntityRef[] = []
+    const unreachable: SourceEntityRef[] = []
+    for (const entity of entities) {
+        if (!entity.owner.equals(target.ownerName)) continue
+        if (entity.id.equals(target.entityId)) continue
+        if (!coordsEqual(entity.coordinates, target.coordinates)) continue
+        const relevant = matchRelevantCargo(entity, target, cargo)
+        if (relevant.length === 0) continue
+        const loaderCount = entity.loaders?.quantity.toNumber() ?? 0
+        const loaderTotalMass = entity.loaders?.mass.toNumber() ?? 0
+        const ref: SourceEntityRef = {
+            entityId: entity.id,
+            name: entity.id.toString(),
+            hasLoaders: loaderCount > 0,
+            loaderCount,
+            loaderTotalMass,
+            relevantCargo: relevant,
+        }
+        if (ref.hasLoaders) eligible.push(ref)
+        else unreachable.push(ref)
+    }
+    return {eligible, unreachable}
+}

package/src/managers/index.ts

@@ -9,3 +9,14 @@ export {EpochsManager} from './epochs'
 export {ActionsManager} from './actions'
 export {NftManager} from './nft'
 export type {NftConfigForItem} from './nft'
+export {PlotManager} from './plot'
+export type {PlotProgress, PlotProgressInputRow} from './plot'
+export {ConstructionManager} from './construction'
+export type {
+    BuildableTarget,
+    BuildState,
+    SourceEntityRef,
+    SourceCargoStack,
+    FinalizerEntityRef,
+    FinalizerCapability,
+} from './construction-types'

package/src/managers/plot.ts

@@ -0,0 +1,123 @@
+import {Name} from '@wharfkit/antelope'
+import {getItem} from '../data/catalog'
+import {getRecipe, resolveRecipeInputItemId} from '../data/recipes-runtime'
+import {computeInputMass} from '../derivation/crafting'
+import {calc_craft_duration} from '../capabilities/crafting'
+import {TaskType} from '../types'
+import {BaseManager} from './base'
+import type {ServerContract} from '../contracts'
+import type {BuildableTarget} from './construction-types'
+
+export interface PlotProgressInputRow {
+    itemId: number
+    required: number
+    provided: number
+    missing: number
+}
+
+export interface PlotProgress {
+    targetItemId: number
+    rows: PlotProgressInputRow[]
+    massProvided: number
+    massRequired: number
+    isComplete: boolean
+}
+
+export class PlotManager extends BaseManager {
+    progress(
+        plot: ServerContract.Types.entity_row,
+        cargo: ServerContract.Types.cargo_row[]
+    ): PlotProgress {
+        const targetItemId = Number(plot.item_id.toString())
+        const recipe = getRecipe(targetItemId)
+        if (!recipe) {
+            throw new Error(`No recipe found for item ${targetItemId}`)
+        }
+
+        const plotId = plot.id.toString()
+        const plotCargo = cargo.filter((c) => c.entity_id.toString() === plotId)
+
+        const quantityByItemId = new Map<number, number>()
+        for (const c of plotCargo) {
+            const id = c.item_id.toNumber()
+            quantityByItemId.set(
+                id,
+                (quantityByItemId.get(id) ?? 0) + Number(c.quantity.toString())
+            )
+        }
+
+        const rows: PlotProgressInputRow[] = recipe.inputs.map((input) => {
+            const itemId = resolveRecipeInputItemId(input)
+            const required = input.quantity
+            const provided = quantityByItemId.get(itemId) ?? 0
+            const missing = Math.max(0, required - provided)
+            return {itemId, required, provided, missing}
+        })
+
+        const massRequired = computeInputMass(targetItemId)
+        const massProvided = rows.reduce((sum, r) => {
+            const item = getItem(r.itemId)
+            return sum + item.mass * r.provided
+        }, 0)
+        const isComplete = rows.every((r) => r.missing === 0)
+
+        return {targetItemId, rows, massProvided, massRequired, isComplete}
+    }
+
+    buildableTarget(
+        plot: ServerContract.Types.entity_row,
+        cargo: ServerContract.Types.cargo_row[],
+        activeTask?: ServerContract.Types.task
+    ): BuildableTarget {
+        const progress = this.progress(plot, cargo)
+        const targetItemId = Number(plot.item_id.toString())
+        const targetItem = getItem(targetItemId)
+        const recipe = getRecipe(targetItemId)
+        if (!recipe) {
+            throw new Error(`Plot target item ${targetItemId} has no recipe`)
+        }
+
+        let state: BuildableTarget['state']
+        const taskType = activeTask?.type.toNumber()
+        if (taskType === TaskType.CLAIMPLOT) {
+            state = 'initializing'
+        } else if (taskType === TaskType.BUILDPLOT) {
+            state = 'finalizing'
+        } else if (progress.isComplete) {
+            state = 'ready'
+        } else {
+            state = 'accepting'
+        }
+
+        return {
+            entityId: plot.id,
+            ownerName: plot.owner,
+            coordinates: plot.coordinates,
+            targetItemId,
+            targetItem,
+            state,
+            recipe,
+            progress,
+            finalizeAction: Name.from('buildplot'),
+            finalizerCapability: 'crafter',
+            activeTask,
+        }
+    }
+
+    canBuild(
+        plot: ServerContract.Types.entity_row,
+        cargo: ServerContract.Types.cargo_row[]
+    ): boolean {
+        return this.progress(plot, cargo).isComplete
+    }
+
+    timeToComplete(
+        plot: ServerContract.Types.entity_row,
+        crafter: ServerContract.Types.crafter_stats
+    ): number {
+        const capacity = Number(plot.capacity?.toString() ?? '0')
+        const speed = Number(crafter.speed.toString())
+        if (speed === 0) return 0
+        return calc_craft_duration(speed, capacity).toNumber()
+    }
+}

package/src/nft/buildImmutableData.ts

@@ -193,10 +193,12 @@ export function buildModuleImmutable(
         case MODULE_GATHERER: {
             const str = decodeStat(stats, 0)
             const tol = decodeStat(stats, 1)
-            const con = decodeStat(stats, 3)
+            const con = decodeStat(stats, 2)
+            const ref = decodeStat(stats, 3)
             base.push({first: 'strength', second: ['uint16', str]})
             base.push({first: 'tolerance', second: ['uint16', tol]})
             base.push({first: 'conductivity', second: ['uint16', con]})
+            base.push({first: 'reflectivity', second: ['uint16', ref]})
             base.push({first: 'yield', second: ['uint16', computeGathererYield(str)]})
             base.push({first: 'drain', second: ['uint16', computeGathererDrain(con)]})
             base.push({first: 'depth', second: ['uint16', computeGathererDepth(tol, item.tier)]})
@@ -241,17 +243,15 @@ export function buildModuleImmutable(
             break
         }
         case MODULE_HAULER: {
-            const com = decodeStat(stats, 0)
+            const res = decodeStat(stats, 0)
             const con = decodeStat(stats, 1)
-            const fin = decodeStat(stats, 2)
-            const res = decodeStat(stats, 3)
-            base.push({first: 'composition', second: ['uint16', com]})
-            base.push({first: 'conductivity', second: ['uint16', con]})
-            base.push({first: 'fineness', second: ['uint16', fin]})
+            const ref = decodeStat(stats, 2)
             base.push({first: 'resonance', second: ['uint16', res]})
-            base.push({first: 'capacity', second: ['uint8', computeHaulerCapacity(com)]})
+            base.push({first: 'conductivity', second: ['uint16', con]})
+            base.push({first: 'reflectivity', second: ['uint16', ref]})
+            base.push({first: 'capacity', second: ['uint8', computeHaulerCapacity(res)]})
             base.push({first: 'efficiency', second: ['uint16', computeHaulerEfficiency(con)]})
-            base.push({first: 'drain', second: ['uint16', computeHaulerDrain(fin)]})
+            base.push({first: 'drain', second: ['uint16', computeHaulerDrain(ref)]})
             break
         }
     }

package/src/nft/description.ts

@@ -39,12 +39,12 @@ export function computeBaseHullmass(stats: bigint): number {
 
 export function computeBaseCapacityShip(stats: bigint): number {
     const s = decodeStat(stats, 0) + decodeStat(stats, 2) + decodeStat(stats, 3)
-    return Math.floor(1_000_000 * 10 ** (s / 2997))
+    return Math.floor(5_000_000 * 10 ** (s / 2997))
 }
 
 export function computeBaseCapacityWarehouse(stats: bigint): number {
     const s = decodeStat(stats, 0) + decodeStat(stats, 2) + decodeStat(stats, 3)
-    return Math.floor(20_000_000 * 10 ** (s / 2997))
+    return Math.floor(100_000_000 * 10 ** (s / 2997))
 }
 
 export const computeEngineThrust = (vol: number): number => 400 + idiv(vol * 3, 4)
@@ -131,7 +131,7 @@ export function formatModuleLine(slot: number, itemId: number, stats: bigint): s
         case MODULE_GATHERER: {
             const str = decodeStat(stats, 0)
             const tol = decodeStat(stats, 1)
-            const con = decodeStat(stats, 3)
+            const con = decodeStat(stats, 2)
             const tier = getItem(itemId).tier
             out += `  Yield ${computeGathererYield(str)}  Depth ${computeGathererDepth(
                 tol,
@@ -161,10 +161,10 @@ export function formatModuleLine(slot: number, itemId: number, stats: bigint): s
             break
         }
         case MODULE_HAULER: {
-            const fin = decodeStat(stats, 0)
+            const res = decodeStat(stats, 0)
             const con = decodeStat(stats, 1)
-            const com = decodeStat(stats, 2)
-            out += `  Capacity ${computeHaulerCapacity(fin)}  Efficiency ${computeHaulerEfficiency(con)}  Drain ${computeHaulerDrain(com)}`
+            const ref = decodeStat(stats, 2)
+            out += `  Capacity ${computeHaulerCapacity(res)}  Efficiency ${computeHaulerEfficiency(con)}  Drain ${computeHaulerDrain(ref)}`
             break
         }
         case MODULE_WARP: {

package/src/resolution/describe-module.ts

@@ -63,14 +63,12 @@ const TEMPLATES: Record<string, TemplateSpec> = {
     },
     loader: {
         id: 'module.loader.description',
-        template:
-            '{quantity} loader that generates {thrust} thrust with a weight of {mass} per unit',
+        template: 'generates {thrust} thrust with a weight of {mass} per unit',
         params: [
-            ['quantity', 'Quantity'],
             ['thrust', 'Thrust'],
             ['mass', 'Mass'],
         ],
-        highlightKeys: ['quantity', 'thrust', 'mass'],
+        highlightKeys: ['thrust', 'mass'],
     },
     crafter: {
         id: 'module.crafter.description',

package/src/subscriptions/types.ts

@@ -84,6 +84,7 @@ export type WireEntity = Record<string, unknown> & {
     id: string | number
     owner: string
     coordinates: WireCoordinates
+    item_id: number
 }
 
 export type SnapshotMessage = {

package/src/types.ts

@@ -53,6 +53,8 @@ export enum TaskType {
     UNWRAP = 10,
     UNDEPLOY = 11,
     DEMOLISH = 13,
+    CLAIMPLOT = 14,
+    BUILDPLOT = 15,
 }
 
 export enum LocationType {