@shipload/sdk 2.0.0-rc6 → 2.0.0-rc8

package/src/managers/actions.ts

@@ -120,14 +120,10 @@ export class ActionsManager extends BaseManager {
         entityId: UInt64Type,
         recipeId: number,
         quantity: number,
-        inputs: {itemId: number; quantity: number; seed?: bigint}[]
+        inputs: ServerContract.ActionParams.Type.cargo_item[]
     ): Action {
         const cargoInputs = inputs.map((i) =>
-            ServerContract.Types.cargo_item.from({
-                item_id: UInt16.from(i.itemId),
-                quantity: UInt32.from(i.quantity),
-                seed: i.seed !== undefined ? UInt64.from(i.seed) : null,
-            })
+            ServerContract.Types.cargo_item.from(i)
         )
         return this.server.action('craft', {
             entity_type: entityType,
@@ -138,6 +134,21 @@ export class ActionsManager extends BaseManager {
         })
     }
 
+    blend(
+        entityType: EntityTypeName,
+        entityId: UInt64Type,
+        inputs: ServerContract.ActionParams.Type.cargo_item[]
+    ): Action {
+        const cargoInputs = inputs.map((i) =>
+            ServerContract.Types.cargo_item.from(i)
+        )
+        return this.server.action('blend', {
+            entity_type: entityType,
+            id: UInt64.from(entityId),
+            inputs: cargoInputs,
+        })
+    }
+
     deploy(
         entityType: EntityTypeName,
         entityId: UInt64Type,
@@ -154,6 +165,36 @@ export class ActionsManager extends BaseManager {
         })
     }
 
+    addmodule(
+        entityType: EntityTypeName,
+        entityId: UInt64Type,
+        moduleIndex: number,
+        moduleCargoId: UInt64Type,
+        targetCargoId: UInt64Type = UInt64.from(0)
+    ): Action {
+        return this.server.action('addmodule', {
+            entity_type: entityType,
+            entity_id: UInt64.from(entityId),
+            module_index: moduleIndex,
+            module_cargo_id: UInt64.from(moduleCargoId),
+            target_cargo_id: UInt64.from(targetCargoId),
+        })
+    }
+
+    rmmodule(
+        entityType: EntityTypeName,
+        entityId: UInt64Type,
+        moduleIndex: number,
+        targetCargoId: UInt64Type = UInt64.from(0)
+    ): Action {
+        return this.server.action('rmmodule', {
+            entity_type: entityType,
+            entity_id: UInt64.from(entityId),
+            module_index: moduleIndex,
+            target_cargo_id: UInt64.from(targetCargoId),
+        })
+    }
+
     joinGame(account: NameType, companyName: string): Action[] {
         return [this.foundCompany(account, companyName), this.join(account)]
     }

package/src/resolution/resolve-item.ts

@@ -0,0 +1,261 @@
+import {UInt16, UInt64} from '@wharfkit/antelope'
+import type {UInt16Type, UInt64Type} from '@wharfkit/antelope'
+import type {ResourceCategory, ResourceTier} from '../types'
+import {getItem} from '../market/items'
+import {getComponentById, getModuleRecipeByItemId, getEntityRecipeByItemId} from '../data/recipes'
+import {isModuleItem, getModuleCapabilityType, MODULE_ENGINE, MODULE_GENERATOR, MODULE_EXTRACTOR, MODULE_LOADER, MODULE_CRAFTER} from '../capabilities/modules'
+import {decodeCraftedItemStats} from '../derivation/crafting'
+import {deriveResourceStats} from '../derivation/stratum'
+import {getStatDefinitions} from '../derivation/stats'
+import {computeShipHullCapabilities, computeEngineCapabilities, computeGeneratorCapabilities, computeExtractorCapabilities, computeLoaderCapabilities, computeManufacturingCapabilities} from '../entities/ship-deploy'
+import {computeContainerCapabilities} from '../entities/container'
+import {categoryColors, categoryIcons, componentIcon, moduleIcon, itemIcons} from '../data/colors'
+import {ServerContract} from '../contracts'
+
+export interface ResolvedItemStat {
+    key: string
+    label: string
+    abbreviation: string
+    value: number
+    color: string
+    category: ResourceCategory
+    inverted?: boolean
+}
+
+export interface ResolvedAttributeGroup {
+    capability: string
+    attributes: {label: string; value: number}[]
+}
+
+export type ResolvedItemType = 'resource' | 'component' | 'module' | 'entity'
+
+export interface ResolvedModuleSlot {
+    name?: string
+    installed: boolean
+    attributes?: {label: string; value: number}[]
+}
+
+export interface ResolvedItem {
+    itemId: number
+    name: string
+    icon: string
+    category?: ResourceCategory
+    tier: ResourceTier
+    mass: number
+    itemType: ResolvedItemType
+    stats?: ResolvedItemStat[]
+    attributes?: ResolvedAttributeGroup[]
+    moduleSlots?: ResolvedModuleSlot[]
+}
+
+function toNum(v: UInt16Type): number {
+    return Number(UInt16.from(v).value.toString())
+}
+
+function toBigSeed(v: UInt64Type): bigint {
+    return BigInt(UInt64.from(v).toString())
+}
+
+function resolveResource(id: number, seed?: UInt64Type): ResolvedItem {
+    const item = getItem(id)
+    const cat = item.category
+    let stats: ResolvedItemStat[] | undefined
+    if (seed !== undefined) {
+        const derived = deriveResourceStats(toBigSeed(seed))
+        const defs = getStatDefinitions(cat)
+        const values = [derived.stat1, derived.stat2, derived.stat3]
+        stats = defs.map((d, i) => ({
+            key: d.key,
+            label: d.label,
+            abbreviation: d.abbreviation,
+            value: values[i] ?? 0,
+            color: categoryColors[cat],
+            category: cat,
+            inverted: d.inverted,
+        }))
+    }
+    return {
+        itemId: id,
+        name: String(item.name),
+        icon: categoryIcons[cat] ?? '⬡',
+        category: cat,
+        tier: item.tier,
+        mass: Number(item.mass.value.toString()),
+        itemType: 'resource',
+        stats,
+    }
+}
+
+function resolveComponent(id: number, seed?: 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]) => {
+            const allDefs = getStatDefinitions('metal')
+                .concat(getStatDefinitions('precious'))
+                .concat(getStatDefinitions('gas'))
+                .concat(getStatDefinitions('mineral'))
+                .concat(getStatDefinitions('organic'))
+            const def = allDefs.find((d) => d.key === key)
+            const statDef = comp.stats.find((s) => s.key === key)
+            const cat = (statDef?.source ?? 'metal') as ResourceCategory
+            return {
+                key,
+                label: def?.label ?? key,
+                abbreviation: def?.abbreviation ?? key.slice(0, 3).toUpperCase(),
+                value,
+                color: categoryColors[cat],
+                category: cat,
+                inverted: def?.inverted,
+            }
+        })
+    }
+    return {
+        itemId: id,
+        name: comp.name,
+        icon: itemIcons[id] ?? componentIcon,
+        tier: 't1' as ResourceTier,
+        mass: comp.mass,
+        itemType: 'component',
+        stats,
+    }
+}
+
+function computeCapabilityGroup(moduleType: number, stats: Record<string, number>): ResolvedAttributeGroup | undefined {
+    switch (moduleType) {
+        case MODULE_ENGINE: {
+            const caps = computeEngineCapabilities(stats)
+            return {capability: 'Engine', attributes: [
+                {label: 'Thrust', value: caps.thrust},
+                {label: 'Drain', value: caps.drain},
+            ]}
+        }
+        case MODULE_GENERATOR: {
+            const caps = computeGeneratorCapabilities(stats)
+            return {capability: 'Generator', attributes: [
+                {label: 'Capacity', value: caps.capacity},
+                {label: 'Recharge', value: caps.recharge},
+            ]}
+        }
+        case MODULE_EXTRACTOR: {
+            const caps = computeExtractorCapabilities(stats)
+            return {capability: 'Extractor', attributes: [
+                {label: 'Rate', value: caps.rate},
+                {label: 'Drain', value: caps.drain},
+                {label: 'Depth', value: caps.depth},
+                {label: 'Drill', value: caps.drill},
+            ]}
+        }
+        case MODULE_LOADER: {
+            const caps = computeLoaderCapabilities(stats)
+            return {capability: 'Loader', attributes: [
+                {label: 'Mass', value: caps.mass},
+                {label: 'Thrust', value: caps.thrust},
+                {label: 'Quantity', value: caps.quantity},
+            ]}
+        }
+        case MODULE_CRAFTER: {
+            const caps = computeManufacturingCapabilities(stats)
+            return {capability: 'Manufacturing', attributes: [
+                {label: 'Speed', value: caps.speed},
+                {label: 'Drain', value: caps.drain},
+            ]}
+        }
+        default:
+            return undefined
+    }
+}
+
+function resolveModule(id: number, seed?: UInt64Type): ResolvedItem {
+    const recipe = getModuleRecipeByItemId(id)!
+    let attributes: ResolvedAttributeGroup[] | undefined
+    if (seed !== undefined) {
+        const stats = decodeCraftedItemStats(id, toBigSeed(seed))
+        const modType = getModuleCapabilityType(id)
+        const group = computeCapabilityGroup(modType, stats)
+        if (group) attributes = [group]
+    }
+    return {
+        itemId: id,
+        name: recipe.name,
+        icon: itemIcons[id] ?? moduleIcon,
+        tier: 't1' as ResourceTier,
+        mass: 0,
+        itemType: 'module',
+        attributes,
+    }
+}
+
+function resolveEntity(id: number, seed?: 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))
+        attributes = []
+
+        const isShip = recipe.id === 'ship-t1'
+        if (isShip) {
+            const hullCaps = computeShipHullCapabilities(stats)
+            attributes.push({capability: 'Hull', attributes: [
+                {label: 'Mass', value: hullCaps.hullmass},
+                {label: 'Capacity', value: hullCaps.capacity},
+            ]})
+        } else {
+            const containerCaps = computeContainerCapabilities(stats)
+            attributes.push({capability: 'Hull', attributes: [
+                {label: 'Mass', value: containerCaps.hullmass},
+                {label: 'Capacity', value: containerCaps.capacity},
+            ]})
+        }
+    }
+
+    if (recipe.moduleSlots) {
+        moduleSlots = recipe.moduleSlots.map((slot, i) => {
+            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 modType = getModuleCapabilityType(modItemId)
+                const group = computeCapabilityGroup(modType, modStats)
+                const modRecipe = getModuleRecipeByItemId(modItemId)
+                return {
+                    name: modRecipe?.name ?? 'Module',
+                    installed: true,
+                    attributes: group?.attributes,
+                }
+            }
+            return {installed: false}
+        })
+    }
+
+    return {
+        itemId: id,
+        name: recipe.name,
+        icon: itemIcons[id] ?? componentIcon,
+        tier: 't1' as ResourceTier,
+        mass: 0,
+        itemType: 'entity',
+        attributes,
+        moduleSlots,
+    }
+}
+
+export function resolveItem(
+    itemId: UInt16Type,
+    seed?: UInt64Type,
+    modules?: ServerContract.Types.module_entry[]
+): ResolvedItem {
+    const id = toNum(itemId)
+
+    if (isModuleItem(id)) return resolveModule(id, seed)
+
+    if (getComponentById(id)) return resolveComponent(id, seed)
+
+    if (getEntityRecipeByItemId(id)) return resolveEntity(id, seed, modules)
+
+    return resolveResource(id, seed)
+}

package/src/travel/travel.ts

@@ -24,7 +24,7 @@ import {ServerContract} from '../contracts'
 import {
     CargoMassInfo,
     Distance,
-    INITIAL_SHIP_MASS,
+    BASE_ORBITAL_MASS,
     MAX_ORBITAL_ALTITUDE,
     MIN_ORBITAL_ALTITUDE,
     PRECISION,
@@ -35,11 +35,11 @@ import {getItem} from '../market/items'
 import {hasSystem} from '../utils/system'
 
 export function calc_orbital_altitude(mass: number): number {
-    if (mass <= INITIAL_SHIP_MASS) {
+    if (mass <= BASE_ORBITAL_MASS) {
         return MIN_ORBITAL_ALTITUDE
     }
 
-    const ratio = mass / INITIAL_SHIP_MASS
+    const ratio = mass / BASE_ORBITAL_MASS
     const capRatio = 10.0
     let scale = Math.log(ratio) / Math.log(capRatio)
     scale = Math.min(scale, 1.0)

package/src/types/entity.ts

@@ -19,10 +19,10 @@ export interface Entity {
 }
 
 export type ShipEntity = Entity &
-    MovementCapability &
-    EnergyCapability &
+    Partial<MovementCapability> &
+    Partial<EnergyCapability> &
     StorageCapability &
-    LoaderCapability &
+    Partial<LoaderCapability> &
     MassCapability &
     ScheduleCapability & {
         extractor?: ServerContract.Types.extractor_stats

package/src/types.ts

@@ -12,19 +12,6 @@ import {ServerContract} from './contracts'
 
 export const PRECISION = 10000
 
-export const INITIAL_SHIP_GENERATOR_CAPACITY = 350
-export const INITIAL_SHIP_DRAIN = 25
-export const INITIAL_SHIP_ENERGY = 350
-export const INITIAL_SHIP_HULLMASS = 100000
-export const INITIAL_SHIP_CAPACITY = 500000
-export const INITIAL_SHIP_Z = 800
-export const INITIAL_SHIP_RECHARGE = 10
-export const INITIAL_SHIP_THRUST = 250
-
-export const INITIAL_LOADER_MASS = 1000
-export const INITIAL_LOADER_QUANTITY = 1
-export const INITIAL_LOADER_THRUST = 1
-
 export const WAREHOUSE_Z = 500
 export const INITIAL_WAREHOUSE_CAPACITY = 10000000
 
@@ -37,11 +24,7 @@ export const TRAVEL_MAX_DURATION = 86400
 export const MIN_ORBITAL_ALTITUDE = 800
 export const MAX_ORBITAL_ALTITUDE = 3000
 
-export const INITIAL_SHIP_MASS = 500000
-
-export const INITIAL_EXTRACTOR_RATE = 700
-export const INITIAL_EXTRACTOR_DRAIN = 2500
-export const INITIAL_EXTRACTOR_EFFICIENCY = 5000
+export const BASE_ORBITAL_MASS = 100000
 
 export interface ShipLike {
     coordinates: ServerContract.Types.coordinates