@shipload/sdk 2.0.0-rc20 → 2.0.0-rc22

package/src/scheduling/projection.ts

@@ -1,4 +1,4 @@
-import {Name, UInt16, UInt32, UInt64} from '@wharfkit/antelope'
+import {Name, TimePoint, UInt16, UInt32, UInt64} from '@wharfkit/antelope'
 import {ServerContract} from '../contracts'
 import {Coordinates, PRECISION, TaskType} from '../types'
 import {
@@ -13,16 +13,10 @@ import {
     RECIPE_INPUTS_EXCESS,
     RECIPE_INPUTS_INSUFFICIENT,
     RECIPE_INPUTS_INVALID,
-    RECIPE_INPUTS_MIXED,
     RECIPE_NOT_FOUND,
     SHIP_CARGO_NOT_LOADED,
 } from '../errors'
-import {
-    getComponentById,
-    getEntityRecipeByItemId,
-    getModuleRecipeByItemId,
-    RecipeInput,
-} from '../data/recipes'
+import {getRecipe, RecipeInput} from '../data/recipes-runtime'
 import {getItem} from '../market/items'
 import {distanceBetweenCoordinates, lerp} from '../travel/travel'
 import {
@@ -296,14 +290,41 @@ export function projectEntity(entity: Projectable, options?: ProjectionOptions):
     return projected
 }
 
-function getRecipeForOutput(outputItemId: number): RecipeInput[] | undefined {
-    const component = getComponentById(outputItemId)
-    if (component) return component.recipe
-    const moduleRecipe = getModuleRecipeByItemId(outputItemId)
-    if (moduleRecipe) return moduleRecipe.recipe
-    const entityRecipe = getEntityRecipeByItemId(outputItemId)
-    if (entityRecipe) return entityRecipe.recipe
-    return undefined
+export interface ProjectableSnapshot extends Projectable {
+    current_task?: ServerContract.Types.task
+    pending_tasks?: ServerContract.Types.task[]
+}
+
+function buildRemainingProjectable(snapshot: ProjectableSnapshot): Projectable | null {
+    if (!snapshot.schedule) return null
+    const remainingTasks: ServerContract.Types.task[] = []
+    if (snapshot.current_task) remainingTasks.push(snapshot.current_task)
+    if (snapshot.pending_tasks?.length) remainingTasks.push(...snapshot.pending_tasks)
+    if (remainingTasks.length === 0) return null
+
+    const completedCount = snapshot.schedule.tasks.length - remainingTasks.length
+    let startedMs = snapshot.schedule.started.toMilliseconds()
+    for (let i = 0; i < completedCount; i++) {
+        startedMs += snapshot.schedule.tasks[i].duration.toNumber() * 1000
+    }
+
+    return {
+        ...snapshot,
+        schedule: ServerContract.Types.schedule.from({
+            started: TimePoint.fromMilliseconds(startedMs),
+            tasks: remainingTasks,
+        }),
+    }
+}
+
+export function projectFromCurrentState(snapshot: ProjectableSnapshot): ProjectedEntity {
+    const projectable = buildRemainingProjectable(snapshot)
+    return projectable ? projectEntity(projectable) : createProjectedEntity(snapshot)
+}
+
+function getRecipeInputsForOutput(outputItemId: number): RecipeInput[] | undefined {
+    const recipe = getRecipe(outputItemId)
+    return recipe?.inputs
 }
 
 function validateCraftTask(task: ServerContract.Types.task, projected: ProjectedEntity): void {
@@ -313,7 +334,7 @@ function validateCraftTask(task: ServerContract.Types.task, projected: Projected
     const inputs = task.cargo.slice(0, -1)
     const craftQuantity = output.quantity.toNumber()
 
-    const recipe = getRecipeForOutput(output.item_id.toNumber())
+    const recipe = getRecipeInputsForOutput(output.item_id.toNumber())
     if (!recipe) throw new Error(RECIPE_NOT_FOUND)
 
     const groupedInputs: ServerContract.Types.cargo_item[][] = recipe.map(() => [])
@@ -321,15 +342,15 @@ function validateCraftTask(task: ServerContract.Types.task, projected: Projected
         let matched = false
         for (let ri = 0; ri < recipe.length; ri++) {
             const req = recipe[ri]
-            if (req.itemId && req.itemId > 0) {
+            if ('itemId' in req) {
                 if (input.item_id.toNumber() === req.itemId) {
                     groupedInputs[ri].push(input)
                     matched = true
                     break
                 }
-            } else if (req.category) {
+            } else {
                 const item = getItem(input.item_id)
-                if (item.category === req.category) {
+                if (item.category === req.category && item.tier === req.tier) {
                     groupedInputs[ri].push(input)
                     matched = true
                     break
@@ -348,15 +369,6 @@ function validateCraftTask(task: ServerContract.Types.task, projected: Projected
         const required = recipe[ri].quantity * craftQuantity
         if (provided < required) throw new Error(RECIPE_INPUTS_INSUFFICIENT)
         if (provided !== required) throw new Error(RECIPE_INPUTS_EXCESS)
-
-        if (!recipe[ri].itemId && stacks.length > 1) {
-            const firstItemId = stacks[0].item_id.toNumber()
-            for (let si = 1; si < stacks.length; si++) {
-                if (stacks[si].item_id.toNumber() !== firstItemId) {
-                    throw new Error(RECIPE_INPUTS_MIXED)
-                }
-            }
-        }
     }
 
     for (const input of inputs) {
@@ -441,3 +453,11 @@ export function projectEntityAt(entity: Projectable, now: Date): ProjectedEntity
 
     return projected
 }
+
+export function projectFromCurrentStateAt(
+    snapshot: ProjectableSnapshot,
+    now: Date
+): ProjectedEntity {
+    const projectable = buildRemainingProjectable(snapshot)
+    return projectable ? projectEntityAt(projectable, now) : createProjectedEntity(snapshot)
+}

package/src/travel/travel.ts

@@ -174,7 +174,8 @@ export function calc_ship_mass(ship: ShipLike, cargos: CargoMassInfo[]): UInt64
     }
 
     for (const cargo of cargos) {
-        mass.add(getItem(cargo.item_id).mass.multiplying(cargo.quantity))
+        const cargoMass = getItem(cargo.item_id).mass * Number(UInt32.from(cargo.quantity))
+        mass.add(UInt64.from(cargoMass))
     }
 
     return mass
@@ -195,8 +196,8 @@ export function calculateTransferTime(
         const qty = quantities?.get(Number(cargo.item_id)) ?? 0
         if (qty > 0) {
             const good_mass = getItem(cargo.item_id).mass
-            const cargo_mass = good_mass.multiplying(qty)
-            mass = UInt64.from(mass).adding(cargo_mass)
+            const cargo_mass = good_mass * qty
+            mass = UInt64.from(mass).adding(UInt64.from(cargo_mass))
         }
     }
 
@@ -249,12 +250,12 @@ export function calculateLoadTimeBreakdown(
             const good = getItem(cargo.item_id)
 
             if (loadQty > 0) {
-                const cargo_mass = good.mass.multiplying(loadQty)
-                mass_load = UInt64.from(mass_load).adding(cargo_mass)
+                const cargo_mass = good.mass * loadQty
+                mass_load = UInt64.from(mass_load).adding(UInt64.from(cargo_mass))
             }
             if (unloadQty > 0) {
-                const cargo_mass = good.mass.multiplying(unloadQty)
-                mass_unload = UInt64.from(mass_unload).adding(cargo_mass)
+                const cargo_mass = good.mass * unloadQty
+                mass_unload = UInt64.from(mass_unload).adding(UInt64.from(cargo_mass))
             }
         }
     }

package/src/types.ts

@@ -1,13 +1,4 @@
-import {
-    Int64Type,
-    Name,
-    Struct,
-    UInt16,
-    UInt16Type,
-    UInt32,
-    UInt32Type,
-    UInt64,
-} from '@wharfkit/antelope'
+import {Int64Type, Name, UInt16, UInt16Type, UInt32, UInt32Type, UInt64} from '@wharfkit/antelope'
 import {ServerContract} from './contracts'
 
 export const PRECISION = 10000
@@ -110,8 +101,20 @@ export interface Distance {
     distance: UInt16
 }
 
+export type ItemType = 'resource' | 'component' | 'module' | 'entity'
 export type ResourceCategory = 'ore' | 'crystal' | 'gas' | 'regolith' | 'biomass'
 export type ResourceTier = 't1' | 't2' | 't3' | 't4' | 't5'
+export type ModuleType =
+    | 'any'
+    | 'engine'
+    | 'generator'
+    | 'gatherer'
+    | 'loader'
+    | 'warp'
+    | 'crafter'
+    | 'launcher'
+    | 'storage'
+    | 'hauler'
 
 export const TIER_ADJECTIVES: Record<number, string> = {
     1: 'Crude',
@@ -138,27 +141,18 @@ export function tierNumber(tier: string): number {
     return Number(String(tier).replace(/^t/i, ''))
 }
 
-@Struct.type('item')
-export class Item extends Struct {
-    @Struct.field(UInt16)
-    id!: UInt16
-    @Struct.field('string')
-    name!: string
-    @Struct.field('string')
-    description!: string
-    @Struct.field(UInt32)
-    mass!: UInt32
-    @Struct.field('string')
-    category!: ResourceCategory
-    @Struct.field('string')
-    tier!: ResourceTier
-    @Struct.field('string')
-    color!: string
-
-    get displayName(): string {
-        if (this.name && this.name.length > 0) return this.name
-        const adj = TIER_ADJECTIVES[tierNumber(this.tier)] ?? 'Unknown'
-        const cat = CATEGORY_LABELS[this.category] ?? 'Resource'
-        return `${adj} ${cat}`
-    }
+export interface Item {
+    id: number
+    name: string
+    description: string
+    color: string
+    mass: number
+    type: ItemType
+    tier: number
+    category?: ResourceCategory
+    moduleType?: ModuleType
+}
+
+export function formatTier(tier: number): string {
+    return 'T' + tier
 }