@shipload/sdk 1.0.0-next.3 → 1.0.0-next.31

package/src/managers/locations.ts

@@ -1,10 +1,10 @@
-import {type UInt16Type, UInt64, type UInt64Type} from '@wharfkit/antelope'
+import {BlockTimestamp, type UInt16Type} from '@wharfkit/antelope'
 import {BaseManager} from './base'
-import {type CoordinatesType, coordsToLocationId, type Distance} from '../types'
+import type {CoordinatesType, Distance} from '../types'
 import {hasSystem} from '../utils/system'
 import {findNearbyPlanets} from '../travel/travel'
 import type {ServerContract} from '../contracts'
-import {type DerivedStratum, deriveStrata} from '../derivation'
+import {type DerivedStratum, deriveStrata, getEffectiveReserve} from '../derivation'
 
 export interface LocationStratum extends DerivedStratum {
     reserveMax: number
@@ -24,7 +24,10 @@ export class LocationsManager extends BaseManager {
         return findNearbyPlanets(game.config.seed, origin, maxDistance)
     }
 
-    async getStrata(coords: CoordinatesType): Promise<LocationStratum[]> {
+    async getStrata(
+        coords: CoordinatesType,
+        now: BlockTimestamp = BlockTimestamp.fromMilliseconds(Date.now())
+    ): Promise<LocationStratum[]> {
         const game = await this.getGame()
         const state = await this.getState()
 
@@ -36,33 +39,26 @@ export class LocationsManager extends BaseManager {
             y: coords.y,
         })) as ServerContract.Types.stratum_remaining[]
 
-        const overrideMap = new Map<number, number>()
+        const epochSeconds = Number(game.config.epochtime)
+        const overrideMap = new Map<number, ServerContract.Types.stratum_remaining>()
         for (const o of overrides) {
-            overrideMap.set(Number(o.stratum), Number(o.remaining))
+            overrideMap.set(Number(o.stratum), o)
         }
 
-        return derived.map((s) => ({
-            ...s,
-            reserveMax: s.reserve,
-            reserve: overrideMap.get(s.index) ?? s.reserve,
-        }))
-    }
-
-    async getLocationEntity(
-        id: UInt64Type
-    ): Promise<ServerContract.Types.location_row | undefined> {
-        const row = await this.server.table('location').get(UInt64.from(id))
-        return row ?? undefined
-    }
-
-    async getLocationEntityAt(
-        coords: CoordinatesType
-    ): Promise<ServerContract.Types.location_row | undefined> {
-        const id = coordsToLocationId(coords)
-        return this.getLocationEntity(id)
-    }
-
-    async getAllLocationEntities(): Promise<ServerContract.Types.location_row[]> {
-        return this.server.table('location').all()
+        return derived.map((s) => {
+            const override = overrideMap.get(s.index)
+            const reserve = override
+                ? getEffectiveReserve(
+                      {
+                          remaining: override.remaining,
+                          max_reserve: s.reserve,
+                          last_block: override.last_block,
+                      },
+                      now,
+                      epochSeconds
+                  )
+                : s.reserve
+            return {...s, reserveMax: s.reserve, reserve}
+        })
     }
 }

package/src/managers/nft.ts

@@ -0,0 +1,28 @@
+import {UInt64, type UInt64Type} from '@wharfkit/antelope'
+import {BaseManager} from './base'
+import type {ServerContract} from '../contracts'
+
+export interface NftConfigForItem {
+    templateId: number
+    schemaName: string
+}
+
+export class NftManager extends BaseManager {
+    private cache = new Map<string, NftConfigForItem | null>()
+
+    async getNftConfigForItem(itemId: UInt64Type): Promise<NftConfigForItem | undefined> {
+        const id = UInt64.from(itemId)
+        const key = id.toString()
+        if (this.cache.has(key)) {
+            return this.cache.get(key) ?? undefined
+        }
+        const row = (await this.server.table('nftconfig').get(id)) as
+            | ServerContract.Types.nftconfig_row
+            | undefined
+        const result: NftConfigForItem | null = row
+            ? {templateId: Number(row.template_id), schemaName: String(row.schema_name)}
+            : null
+        this.cache.set(key, result)
+        return result ?? undefined
+    }
+}

package/src/managers/plot.ts

@@ -0,0 +1,127 @@
+import {Name} from '@wharfkit/antelope'
+import {getItem} from '../data/catalog'
+import {getRecipe} 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, ScheduledBuild} 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 = input.itemId
+            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,
+        scheduledBuild?: ScheduledBuild
+    ): 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 (scheduledBuild?.hasStarted) {
+            state = 'finalizing'
+        } else if (scheduledBuild) {
+            state = 'scheduled'
+        } else if (taskType === TaskType.CLAIMPLOT) {
+            state = 'initializing'
+        } 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,
+            scheduledBuild,
+        }
+    }
+
+    canBuild(
+        plot: ServerContract.Types.entity_row,
+        cargo: ServerContract.Types.cargo_row[]
+    ): boolean {
+        return this.progress(plot, cargo).isComplete
+    }
+
+    timeToComplete(
+        plot: ServerContract.Types.entity_info,
+        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()
+    }
+}