@shipload/sdk 2.0.0-rc12 → 2.0.0-rc14

package/src/resolution/resolve-item.ts

@@ -10,22 +10,29 @@ import {
     MODULE_ENGINE,
     MODULE_GATHERER,
     MODULE_GENERATOR,
+    MODULE_HAULER,
     MODULE_LOADER,
     MODULE_STORAGE,
 } from '../capabilities/modules'
-import {decodeCraftedItemStats} from '../derivation/crafting'
-import {deriveResourceStats} from '../derivation/stratum'
+import {decodeCraftedItemStats, decodeStat} from '../derivation/crafting'
 import {getStatDefinitions} from '../derivation/stats'
 import {
     computeEngineCapabilities,
     computeGathererCapabilities,
     computeGeneratorCapabilities,
+    computeHaulerCapabilities,
     computeLoaderCapabilities,
     computeManufacturingCapabilities,
     computeShipHullCapabilities,
 } from '../entities/ship-deploy'
 import {computeContainerCapabilities} from '../entities/container'
-import {categoryColors, categoryIcons, componentIcon, itemIcons, moduleIcon} from '../data/colors'
+import {
+    categoryColors,
+    categoryIcons,
+    componentIcon,
+    itemAbbreviations,
+    moduleIcon,
+} from '../data/colors'
 import {ServerContract} from '../contracts'
 
 export interface ResolvedItemStat {
@@ -55,6 +62,7 @@ export interface ResolvedItem {
     itemId: number
     name: string
     icon: string
+    abbreviation: string | null
     category?: ResourceCategory
     tier: ResourceTier
     mass: number
@@ -68,19 +76,19 @@ function toNum(v: UInt16Type): number {
     return Number(UInt16.from(v).value.toString())
 }
 
-function toBigSeed(v: UInt64Type): bigint {
+function toBigStats(v: UInt64Type): bigint {
     return BigInt(UInt64.from(v).toString())
 }
 
-function resolveResource(id: number, seed?: UInt64Type): ResolvedItem {
+function resolveResource(id: number, stats?: UInt64Type): ResolvedItem {
     const item = getItem(id)
     const cat = item.category
-    let stats: ResolvedItemStat[] | undefined
-    if (seed !== undefined) {
-        const derived = deriveResourceStats(toBigSeed(seed))
+    let resolvedStats: ResolvedItemStat[] | undefined
+    if (stats !== undefined) {
+        const bigStats = toBigStats(stats)
         const defs = getStatDefinitions(cat)
-        const values = [derived.stat1, derived.stat2, derived.stat3]
-        stats = defs.map((d, i) => ({
+        const values = [decodeStat(bigStats, 0), decodeStat(bigStats, 1), decodeStat(bigStats, 2)]
+        resolvedStats = defs.map((d, i) => ({
             key: d.key,
             label: d.label,
             abbreviation: d.abbreviation,
@@ -94,20 +102,21 @@ function resolveResource(id: number, seed?: UInt64Type): ResolvedItem {
         itemId: id,
         name: String(item.name),
         icon: categoryIcons[cat] ?? '⬡',
+        abbreviation: null,
         category: cat,
         tier: item.tier,
         mass: Number(item.mass.value.toString()),
         itemType: 'resource',
-        stats,
+        stats: resolvedStats,
     }
 }
 
-function resolveComponent(id: number, seed?: UInt64Type): ResolvedItem {
+function resolveComponent(id: number, stats?: UInt64Type): ResolvedItem {
     const comp = getComponentById(id)!
-    let stats: ResolvedItemStat[] | undefined
-    if (seed !== undefined) {
-        const decoded = decodeCraftedItemStats(id, toBigSeed(seed))
-        stats = Object.entries(decoded).map(([key, value]) => {
+    let resolvedStats: ResolvedItemStat[] | undefined
+    if (stats !== undefined) {
+        const decoded = decodeCraftedItemStats(id, toBigStats(stats))
+        resolvedStats = Object.entries(decoded).map(([key, value]) => {
             const allDefs = getStatDefinitions('metal')
                 .concat(getStatDefinitions('precious'))
                 .concat(getStatDefinitions('gas'))
@@ -130,11 +139,12 @@ function resolveComponent(id: number, seed?: UInt64Type): ResolvedItem {
     return {
         itemId: id,
         name: comp.name,
-        icon: itemIcons[id] ?? componentIcon,
+        icon: itemAbbreviations[id] ?? componentIcon,
+        abbreviation: itemAbbreviations[id] ?? null,
         tier: 't1' as ResourceTier,
         mass: comp.mass,
         itemType: 'component',
-        stats,
+        stats: resolvedStats,
     }
 }
 
@@ -196,6 +206,17 @@ function computeCapabilityGroup(
                 ],
             }
         }
+        case MODULE_HAULER: {
+            const caps = computeHaulerCapabilities(stats)
+            return {
+                capability: 'Hauler',
+                attributes: [
+                    {label: 'Capacity', value: caps.capacity},
+                    {label: 'Efficiency', value: caps.efficiency},
+                    {label: 'Drain', value: caps.drain},
+                ],
+            }
+        }
         case MODULE_STORAGE: {
             const str = stats.strength ?? 500
             const duc = stats.ductility ?? 500
@@ -209,19 +230,20 @@ function computeCapabilityGroup(
     }
 }
 
-function resolveModule(id: number, seed?: UInt64Type): ResolvedItem {
+function resolveModule(id: number, stats?: UInt64Type): ResolvedItem {
     const recipe = getModuleRecipeByItemId(id)!
     let attributes: ResolvedAttributeGroup[] | undefined
-    if (seed !== undefined) {
-        const stats = decodeCraftedItemStats(id, toBigSeed(seed))
+    if (stats !== undefined) {
+        const decoded = decodeCraftedItemStats(id, toBigStats(stats))
         const modType = getModuleCapabilityType(id)
-        const group = computeCapabilityGroup(modType, stats)
+        const group = computeCapabilityGroup(modType, decoded)
         if (group) attributes = [group]
     }
     return {
         itemId: id,
         name: recipe.name,
-        icon: itemIcons[id] ?? moduleIcon,
+        icon: itemAbbreviations[id] ?? moduleIcon,
+        abbreviation: itemAbbreviations[id] ?? null,
         tier: 't1' as ResourceTier,
         mass: 0,
         itemType: 'module',
@@ -231,20 +253,20 @@ function resolveModule(id: number, seed?: UInt64Type): ResolvedItem {
 
 function resolveEntity(
     id: number,
-    seed?: UInt64Type,
+    stats?: UInt64Type,
     modules?: ServerContract.Types.module_entry[]
 ): ResolvedItem {
     const recipe = getEntityRecipeByItemId(id)!
     let attributes: ResolvedAttributeGroup[] | undefined
     let moduleSlots: ResolvedModuleSlot[] | undefined
 
-    if (seed !== undefined) {
-        const stats = decodeCraftedItemStats(id, toBigSeed(seed))
+    if (stats !== undefined) {
+        const decoded = decodeCraftedItemStats(id, toBigStats(stats))
         attributes = []
 
         const isShip = recipe.id === 'ship-t1'
         if (isShip) {
-            const hullCaps = computeShipHullCapabilities(stats)
+            const hullCaps = computeShipHullCapabilities(decoded)
             attributes.push({
                 capability: 'Hull',
                 attributes: [
@@ -253,7 +275,7 @@ function resolveEntity(
                 ],
             })
         } else {
-            const containerCaps = computeContainerCapabilities(stats)
+            const containerCaps = computeContainerCapabilities(decoded)
             attributes.push({
                 capability: 'Hull',
                 attributes: [
@@ -269,10 +291,10 @@ function resolveEntity(
             const mod = modules?.[i]
             if (mod?.installed) {
                 const modItemId = Number(mod.installed.item_id.value.toString())
-                const modSeed = BigInt(mod.installed.seed.toString())
-                const modStats = decodeCraftedItemStats(modItemId, modSeed)
+                const modStats = BigInt(mod.installed.stats.toString())
+                const decodedStats = decodeCraftedItemStats(modItemId, modStats)
                 const modType = getModuleCapabilityType(modItemId)
-                const group = computeCapabilityGroup(modType, modStats)
+                const group = computeCapabilityGroup(modType, decodedStats)
                 const modRecipe = getModuleRecipeByItemId(modItemId)
                 return {
                     name: modRecipe?.name ?? 'Module',
@@ -287,7 +309,8 @@ function resolveEntity(
     return {
         itemId: id,
         name: recipe.name,
-        icon: itemIcons[id] ?? componentIcon,
+        icon: itemAbbreviations[id] ?? componentIcon,
+        abbreviation: itemAbbreviations[id] ?? null,
         tier: 't1' as ResourceTier,
         mass: 0,
         itemType: 'entity',
@@ -298,16 +321,16 @@ function resolveEntity(
 
 export function resolveItem(
     itemId: UInt16Type,
-    seed?: UInt64Type,
+    stats?: UInt64Type,
     modules?: ServerContract.Types.module_entry[]
 ): ResolvedItem {
     const id = toNum(itemId)
 
-    if (isModuleItem(id)) return resolveModule(id, seed)
+    if (isModuleItem(id)) return resolveModule(id, stats)
 
-    if (getComponentById(id)) return resolveComponent(id, seed)
+    if (getComponentById(id)) return resolveComponent(id, stats)
 
-    if (getEntityRecipeByItemId(id)) return resolveEntity(id, seed, modules)
+    if (getEntityRecipeByItemId(id)) return resolveEntity(id, stats, modules)
 
-    return resolveResource(id, seed)
+    return resolveResource(id, stats)
 }

package/src/scheduling/projection.ts

@@ -211,7 +211,9 @@ function applyGatherTask(
 ): void {
     if (!options.complete) return
     applyEnergyCost(projected, task)
-    applyAddCargoTask(projected, task)
+    if (!task.entitytarget) {
+        applyAddCargoTask(projected, task)
+    }
 }
 
 function applyCraftTask(projected: ProjectedEntity, task: ServerContract.Types.task): void {
@@ -259,11 +261,22 @@ function applyTask(projected: ProjectedEntity, task: ServerContract.Types.task):
     }
 }
 
-export function projectEntity(entity: Projectable): ProjectedEntity {
+export interface ProjectionOptions {
+    upToTaskIndex?: number
+}
+
+export function projectEntity(entity: Projectable, options?: ProjectionOptions): ProjectedEntity {
     const projected = createProjectedEntity(entity)
     if (!entity.schedule || entity.schedule.tasks.length === 0) return projected
-    for (const task of entity.schedule.tasks) {
-        applyTask(projected, task)
+
+    const tasks = entity.schedule.tasks
+    const taskCount =
+        options?.upToTaskIndex !== undefined
+            ? Math.max(0, Math.min(options.upToTaskIndex, tasks.length))
+            : tasks.length
+
+    for (let i = 0; i < taskCount; i++) {
+        applyTask(projected, tasks[i])
     }
     return projected
 }

package/src/types/capabilities.ts

@@ -40,6 +40,7 @@ export interface EntityCapabilities {
     loaders?: ServerContract.Types.loader_stats
     gatherer?: ServerContract.Types.gatherer_stats
     crafter?: ServerContract.Types.crafter_stats
+    hauler?: ServerContract.Types.hauler_stats
 }
 
 export interface EntityState {
@@ -69,3 +70,7 @@ export function capsHasGatherer(caps: EntityCapabilities): boolean {
 export function capsHasMass(caps: EntityCapabilities): boolean {
     return caps.hullmass !== undefined
 }
+
+export function capsHasHauler(caps: EntityCapabilities): boolean {
+    return caps.hauler !== undefined
+}