@shipload/sdk 2.0.0-rc8 → 2.0.0-rc9

package/src/nft/description.ts

@@ -0,0 +1,173 @@
+import {
+    ITEM_ENGINE_T1,
+    ITEM_EXTRACTOR_T1,
+    ITEM_GENERATOR_T1,
+    ITEM_LOADER_T1,
+    ITEM_MANUFACTURING_T1,
+    ITEM_STORAGE_T1,
+    MODULE_CRAFTER,
+    MODULE_ENGINE,
+    MODULE_EXTRACTOR,
+    MODULE_GENERATOR,
+    MODULE_LOADER,
+    MODULE_STORAGE,
+    getModuleCapabilityType,
+} from '../capabilities/modules'
+import {
+    ITEM_CONTAINER_T1_PACKED,
+    ITEM_CONTAINER_T2_PACKED,
+    ITEM_SHIP_T1_PACKED,
+    ITEM_WAREHOUSE_T1_PACKED,
+} from '../data/recipes'
+import {decodeStat} from '../derivation/crafting'
+
+function idiv(a: number, b: number): number {
+    return Math.floor(a / b)
+}
+
+export function computeBaseHullmass(seed: bigint): number {
+    const density = decodeStat(seed, 1)
+    return 25000 + 75 * density
+}
+
+export function computeBaseCapacityShip(seed: bigint): number {
+    const s = decodeStat(seed, 0) + decodeStat(seed, 2) + decodeStat(seed, 3)
+    return Math.floor(1_000_000 * Math.pow(10, s / 2997))
+}
+
+export function computeBaseCapacityWarehouse(seed: bigint): number {
+    const s = decodeStat(seed, 0) + decodeStat(seed, 2) + decodeStat(seed, 3)
+    return Math.floor(20_000_000 * Math.pow(10, s / 2997))
+}
+
+export const computeEngineThrust = (vol: number): number => 400 + idiv(vol * 3, 4)
+export const computeEngineDrain = (thm: number): number => Math.max(30, 50 - idiv(thm, 70))
+export const computeGeneratorCap = (res: number): number => 300 + idiv(res, 6)
+export const computeGeneratorRech = (clr: number): number => 5 + idiv(clr * 15, 1000)
+export const computeExtractorRate = (str: number): number => 200 + str
+export const computeExtractorDrain = (con: number): number => Math.max(10, 50 - idiv(con, 20))
+export const computeExtractorDepth = (tol: number): number => 200 + idiv(tol * 3, 2)
+export const computeExtractorDrill = (ref: number): number => 100 + idiv(ref * 4, 5)
+export const computeLoaderMass = (duc: number): number => Math.max(200, 2000 - duc * 2)
+export const computeLoaderThrust = (pla: number): number => 1 + idiv(pla, 500)
+export const computeCrafterSpeed = (rea: number): number => 100 + idiv(rea * 4, 5)
+export const computeCrafterDrain = (clr: number): number => Math.max(5, 30 - idiv(clr, 33))
+
+export function entityDisplayName(itemId: number): string {
+    switch (itemId) {
+        case ITEM_SHIP_T1_PACKED:
+            return 'Ship T1'
+        case ITEM_WAREHOUSE_T1_PACKED:
+            return 'Warehouse T1'
+        case ITEM_CONTAINER_T1_PACKED:
+            return 'Container T1'
+        case ITEM_CONTAINER_T2_PACKED:
+            return 'Container T2'
+        default:
+            return 'Entity'
+    }
+}
+
+export function moduleDisplayName(itemId: number): string {
+    switch (itemId) {
+        case ITEM_ENGINE_T1:
+            return 'Engine T1'
+        case ITEM_GENERATOR_T1:
+            return 'Generator T1'
+        case ITEM_EXTRACTOR_T1:
+            return 'Extractor T1'
+        case ITEM_LOADER_T1:
+            return 'Loader T1'
+        case ITEM_MANUFACTURING_T1:
+            return 'Manufacturing T1'
+        case ITEM_STORAGE_T1:
+            return 'Storage T1'
+        default:
+            return 'Module'
+    }
+}
+
+export function formatModuleLine(slot: number, itemId: number, seed: bigint): string {
+    let out = `Slot ${slot} - `
+    if (itemId === 0) {
+        out += '(empty)'
+        return out
+    }
+
+    out += moduleDisplayName(itemId)
+    const subtype = getModuleCapabilityType(itemId)
+
+    switch (subtype) {
+        case MODULE_ENGINE: {
+            const vol = decodeStat(seed, 0)
+            const thm = decodeStat(seed, 1)
+            out += `  Thrust ${computeEngineThrust(vol)}  Drain ${computeEngineDrain(thm)}`
+            break
+        }
+        case MODULE_GENERATOR: {
+            const res = decodeStat(seed, 0)
+            const clr = decodeStat(seed, 1)
+            out += `  Capacity ${computeGeneratorCap(res)}  Recharge ${computeGeneratorRech(clr)}`
+            break
+        }
+        case MODULE_EXTRACTOR: {
+            const str = decodeStat(seed, 0)
+            const tol = decodeStat(seed, 1)
+            const con = decodeStat(seed, 3)
+            const ref = decodeStat(seed, 4)
+            out += `  Rate ${computeExtractorRate(str)}  Depth ${computeExtractorDepth(tol)}  Drill ${computeExtractorDrill(ref)}  Drain ${computeExtractorDrain(con)}`
+            break
+        }
+        case MODULE_LOADER: {
+            const duc = decodeStat(seed, 0)
+            const pla = decodeStat(seed, 1)
+            out += `  Mass ${computeLoaderMass(duc)}  Thrust ${computeLoaderThrust(pla)}`
+            break
+        }
+        case MODULE_CRAFTER: {
+            const rea = decodeStat(seed, 0)
+            const clr = decodeStat(seed, 1)
+            out += `  Speed ${computeCrafterSpeed(rea)}  Drain ${computeCrafterDrain(clr)}`
+            break
+        }
+        case MODULE_STORAGE: {
+            const str = decodeStat(seed, 0)
+            const duc = decodeStat(seed, 1)
+            const pur = decodeStat(seed, 2)
+            const sum = str + duc + pur
+            const pct = 10 + idiv(sum * 10, 2997)
+            out += `  +${pct}% capacity`
+            break
+        }
+    }
+    return out
+}
+
+export function buildEntityDescription(
+    itemId: number,
+    hullSeed: bigint,
+    moduleItems: number[],
+    moduleSeeds: bigint[]
+): string {
+    const hullMass = computeBaseHullmass(hullSeed)
+    let baseCapacity = 0
+    if (itemId === ITEM_SHIP_T1_PACKED) {
+        baseCapacity = computeBaseCapacityShip(hullSeed)
+    } else if (itemId === ITEM_WAREHOUSE_T1_PACKED) {
+        baseCapacity = computeBaseCapacityWarehouse(hullSeed)
+    }
+
+    let out = entityDisplayName(itemId)
+    out += ` - Hull ${hullMass} mass`
+    if (baseCapacity > 0) {
+        out += ` * ${baseCapacity} capacity`
+    }
+    out += '\n\n'
+
+    for (let i = 0; i < moduleItems.length; i++) {
+        out += formatModuleLine(i, moduleItems[i], moduleSeeds[i] ?? 0n)
+        out += '\n'
+    }
+
+    return out
+}

package/src/nft/deserializers.ts

@@ -0,0 +1,81 @@
+import {getEntitySlotLayout} from '../data/recipes'
+import {
+    ITEM_TYPE_COMPONENT,
+    ITEM_TYPE_ENTITY,
+    ITEM_TYPE_MODULE,
+    ITEM_TYPE_RESOURCE,
+    itemTypeCode,
+} from '../data/tiers'
+
+export interface NFTInstalledModule {
+    item_id: number
+    seed: string
+}
+
+export interface NFTModuleSlot {
+    type: number
+    installed?: NFTInstalledModule
+}
+
+export interface NFTCargoItem {
+    item_id: number
+    quantity: number
+    seed: string
+    modules?: NFTModuleSlot[]
+}
+
+export interface NFTCommonBase {
+    quantity: number
+    seed: string
+    origin_x: string
+    origin_y: string
+}
+
+export function readCommonBase(data: Record<string, any>): NFTCommonBase {
+    return {
+        quantity: Number(data.quantity),
+        seed: String(data.seed),
+        origin_x: String(data.origin_x),
+        origin_y: String(data.origin_y),
+    }
+}
+
+export function deserializeScalar(data: Record<string, any>, itemId: number): NFTCargoItem {
+    const base = readCommonBase(data)
+    return {item_id: itemId, quantity: base.quantity, seed: base.seed}
+}
+
+export const deserializeResource = deserializeScalar
+export const deserializeComponent = deserializeScalar
+export const deserializeModule = deserializeScalar
+
+export function deserializeEntity(data: Record<string, any>, itemId: number): NFTCargoItem {
+    const base = readCommonBase(data)
+    const moduleItems: number[] = (data.module_items ?? []).map((v: any) => Number(v))
+    const moduleSeeds: string[] = (data.module_seeds ?? []).map((v: any) => String(v))
+    const layout = getEntitySlotLayout(itemId)
+
+    const modules: NFTModuleSlot[] = layout.map((slot, i) => ({
+        type: slot.type,
+        installed:
+            moduleItems[i] && moduleItems[i] !== 0
+                ? {item_id: moduleItems[i], seed: moduleSeeds[i]}
+                : undefined,
+    }))
+
+    return {item_id: itemId, quantity: base.quantity, seed: base.seed, modules}
+}
+
+export function deserializeAsset(data: Record<string, any>, itemId: number): NFTCargoItem {
+    const type = itemTypeCode(itemId)
+    switch (type) {
+        case ITEM_TYPE_RESOURCE:
+        case ITEM_TYPE_COMPONENT:
+        case ITEM_TYPE_MODULE:
+            return deserializeScalar(data, itemId)
+        case ITEM_TYPE_ENTITY:
+            return deserializeEntity(data, itemId)
+        default:
+            throw new Error(`unknown item type ${type} for item ${itemId}`)
+    }
+}

package/src/nft/index.ts

@@ -0,0 +1,2 @@
+export * from './deserializers'
+export * from './description'

package/src/resolution/resolve-item.ts

@@ -3,7 +3,7 @@ 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 {isModuleItem, getModuleCapabilityType, MODULE_ENGINE, MODULE_GENERATOR, MODULE_EXTRACTOR, MODULE_LOADER, MODULE_CRAFTER, MODULE_STORAGE} from '../capabilities/modules'
 import {decodeCraftedItemStats} from '../derivation/crafting'
 import {deriveResourceStats} from '../derivation/stratum'
 import {getStatDefinitions} from '../derivation/stats'
@@ -162,6 +162,16 @@ function computeCapabilityGroup(moduleType: number, stats: Record<string, number
                 {label: 'Drain', value: caps.drain},
             ]}
         }
+        case MODULE_STORAGE: {
+            const str = stats.strength ?? 500
+            const duc = stats.ductility ?? 500
+            const pur = stats.purity ?? 500
+            const statSum = str + duc + pur
+            const pct = 10 + Math.floor(statSum * 10 / 2997)
+            return {capability: 'Storage', attributes: [
+                {label: 'Capacity Bonus', value: pct},
+            ]}
+        }
         default:
             return undefined
     }

package/src/travel/travel.ts

@@ -14,6 +14,7 @@ import {
     Checksum256,
     Int64,
     Int64Type,
+    UInt16,
     UInt32,
     UInt32Type,
     UInt64,
@@ -126,7 +127,8 @@ export function calc_rechargetime(
 }
 
 export function calc_ship_rechargetime(ship: ShipLike): UInt32 {
-    return calc_rechargetime(ship.generator.capacity, ship.energy, ship.generator.recharge)
+    if (!ship.generator) return UInt32.from(0)
+    return calc_rechargetime(ship.generator.capacity, ship.energy ?? UInt16.from(0), ship.generator.recharge)
 }
 
 export function calc_flighttime(distance: UInt64Type, acceleration: number): UInt32 {
@@ -139,7 +141,9 @@ export function calc_loader_flighttime(ship: ShipLike, mass: UInt64, altitude?:
 }
 
 export function calc_loader_acceleration(ship: ShipLike, mass: UInt64): number {
-    return calc_acceleration(Number(ship.loaders.thrust), Number(mass) + Number(ship.loaders.mass))
+    const thrust = ship.loaders ? Number(ship.loaders.thrust) : 0
+    const loaderMass = ship.loaders ? Number(ship.loaders.mass) : 0
+    return calc_acceleration(thrust, Number(mass) + loaderMass)
 }
 
 export function calc_ship_flighttime(ship: ShipLike, mass: UInt64, distance: UInt64): UInt32 {
@@ -148,7 +152,8 @@ export function calc_ship_flighttime(ship: ShipLike, mass: UInt64, distance: UIn
 }
 
 export function calc_ship_acceleration(ship: ShipLike, mass: UInt64): number {
-    return calc_acceleration(Number(ship.engines.thrust), Number(mass))
+    const thrust = ship.engines ? Number(ship.engines.thrust) : 0
+    return calc_acceleration(thrust, Number(mass))
 }
 
 export function calc_acceleration(thrust: number, mass: number): number {
@@ -160,7 +165,7 @@ export function calc_ship_mass(ship: ShipLike, cargos: CargoMassInfo[]): UInt64
 
     mass.add(ship.hullmass)
 
-    if (ship.loaders.quantity.gt(UInt32.zero)) {
+    if (ship.loaders && ship.loaders.quantity.gt(UInt32.zero)) {
         mass.add(ship.loaders.mass.multiplying(ship.loaders.quantity))
     }
 
@@ -195,6 +200,7 @@ export function calculateTransferTime(
         return UInt32.from(0)
     }
 
+    if (!ship.loaders) return UInt32.from(0)
     mass = UInt64.from(mass).adding(ship.loaders.mass)
     const transfer_time = calc_loader_flighttime(ship, mass)
     return transfer_time.dividing(ship.loaders.quantity)
@@ -252,17 +258,17 @@ export function calculateLoadTimeBreakdown(
     let unloadTime = 0
     let loadTime = 0
 
-    if (mass_unload.gt(UInt64.zero)) {
+    if (mass_unload.gt(UInt64.zero) && ship.loaders) {
         const totalMass = UInt64.from(mass_unload).adding(ship.loaders.mass)
         unloadTime = Number(calc_loader_flighttime(ship, totalMass))
     }
 
-    if (mass_load.gt(UInt64.zero)) {
+    if (mass_load.gt(UInt64.zero) && ship.loaders) {
         const totalMass = UInt64.from(mass_load).adding(ship.loaders.mass)
         loadTime = Number(calc_loader_flighttime(ship, totalMass))
     }
 
-    const numLoaders = Number(ship.loaders.quantity)
+    const numLoaders = ship.loaders ? Number(ship.loaders.quantity) : 0
     const totalTime = numLoaders > 0 ? (unloadTime + loadTime) / numLoaders : 0
     const unloadTimePerLoader = numLoaders > 0 ? unloadTime / numLoaders : 0
     const loadTimePerLoader = numLoaders > 0 ? loadTime / numLoaders : 0
@@ -307,6 +313,7 @@ export function estimateTravelTime(
     if (
         loadMass &&
         UInt32.from(loadMass).gt(UInt32.zero) &&
+        ship.loaders &&
         ship.loaders.quantity.gt(UInt32.zero)
     ) {
         const totalMass = UInt64.from(loadMass).adding(ship.loaders.mass)
@@ -316,6 +323,7 @@ export function estimateTravelTime(
     if (
         unloadMass &&
         UInt32.from(unloadMass).gt(UInt32.zero) &&
+        ship.loaders &&
         ship.loaders.quantity.gt(UInt32.zero)
     ) {
         const totalMass = UInt64.from(unloadMass).adding(ship.loaders.mass)
@@ -346,8 +354,9 @@ export function estimateDealTravelTime(
 }
 
 export function hasEnergyForDistance(ship: ShipLike, distance: UInt64Type): boolean {
+    if (!ship.engines) return false
     const energyNeeded = UInt64.from(distance).dividing(PRECISION).multiplying(ship.engines.drain)
-    return UInt64.from(ship.energy).gte(energyNeeded)
+    return UInt64.from(ship.energy ?? 0).gte(energyNeeded)
 }
 
 export interface TransferEntity {

package/src/types/entity.ts

@@ -28,7 +28,7 @@ export type ShipEntity = Entity &
         extractor?: ServerContract.Types.extractor_stats
     }
 
-export type WarehouseEntity = Entity & StorageCapability & LoaderCapability & ScheduleCapability
+export type WarehouseEntity = Entity & StorageCapability & Partial<LoaderCapability> & MassCapability & ScheduleCapability
 
 export type ContainerEntity = Entity & StorageCapability & MassCapability & ScheduleCapability
 

package/src/types.ts

@@ -28,12 +28,12 @@ export const BASE_ORBITAL_MASS = 100000
 
 export interface ShipLike {
     coordinates: ServerContract.Types.coordinates
-    hullmass: UInt32
-    energy: UInt16
-    engines: ServerContract.Types.movement_stats
-    generator: ServerContract.Types.energy_stats
-    loaders: ServerContract.Types.loader_stats
-    capacity: UInt32
+    hullmass?: UInt32
+    energy?: UInt16
+    engines?: ServerContract.Types.movement_stats
+    generator?: ServerContract.Types.energy_stats
+    loaders?: ServerContract.Types.loader_stats
+    capacity?: UInt32
 }
 
 export interface CargoMassInfo {